Ginjo · Gateway Console

POLICY-AWARE MODEL GATEWAY

See every decision before it reaches a model.

Configure a safe test policy, run real OpenAI-compatible requests, and follow each one from authentication through guard screening and model routing.

G Guard Route Trace

Waiting for a connection

Gateway version —

LIVE DEPENDENCIES

System health

Unknown

G GatewayIngress and policy Waiting

S Safety guardRules and local classifier Waiting

R Model providerOpenRouter routing Waiting

Requests in view — Latest trace window

Pass rate — No decisions loaded

Policy mode — Connect to inspect

Tests this session 0 Run from the visual lab

DECISION MIX

Recent verdicts

Pass 0 Rewrite 0 Block 0 Escalate 0

SESSION ACTIVITY

Latest test runs

◎

Your visual test results will appear here.

TEST CONFIGURATION

Policy studio

Orchestrate the request path visually, or author the same policy as developer-friendly YAML.

Not loaded

◎

Configuration scope

Overrides are isolated to one tenant and application.

Tenant ID Application ID

Safe demo override. Saved changes live only in gateway memory and disappear when the gateway restarts. Production runtime editing is always disabled.

VISUAL ORCHESTRATION

Request policy graph

Drag blocks to organize the flow. Pinch or hold Ctrl/⌘ while scrolling to zoom.

GINJO POLICY · V1

Developer view

Synchronized

The graph and YAML describe the same enforceable policy. Apply YAML changes before saving.

Advanced controlsEdit every policy field with form controls.

01 · ENFORCEMENT

Choose how decisions behave

Enforce Block, rewrite, or escalate before any model egress. Shadow Record guard verdicts while allowing screened traffic through.

02 · ROUTING

Models and budget

Default route Maximum output tokens Allowed model routes Comma-separated route IDs. Use * to permit every configured route. Guard failure mode Require system messageReject requests without one.

03 · TOOLS

Tool boundaries

Allowed tools Leave empty to deny tools. Use * to allow all. High-risk tools Require approval for high-risk toolsApproval uses a separate authenticated token. High-risk finding action

04 · SAFETY ACTIONS

Map findings to decisions

Each detector finding resolves to one of Ginjo’s four verdicts.

Secrets Direct injection Indirect injection Ambiguous injection Misconfiguration High-risk tool

05 · THRESHOLDS

Injection sensitivity

Escalate threshold 0.55 Block threshold 0.85

Ambiguous findings above the first threshold escalate; high-confidence findings above the second threshold block.

06 · BOUNDS

Request limits

Maximum messages Maximum tools Block on detector errorKeep the safety boundary closed when a detector fails.

07 · DATA & REWRITES

Evidence handling

Allow safe rewritesPermit redaction and bounded request correction. Retain request payloadsOff by default. Metadata-only traces are safer.

Policy metadata (JSON)

No unsaved changes Load a connected scope to edit its policy.

Inspect effective policy JSON

Connect to load policy.

VISUAL EVALUATION

Test lab

Send real requests through Ginjo and inspect policy, guard, route, response, and trace evidence together.

REQUEST BUILDER

Clean request

Expect PASS

API surface Model route System message User prompt Output token limit Tool name (optional)

Attach approval token Stream response

◎

Ready for a real request

Select a baseline scenario or customize the request, then run it through the connected gateway.

THIS BROWSER SESSION

Run history

◎

No tests run yet.

DEVELOPER ACCESS

Gateway API keys

Create revocable keys for SDKs and server applications. Each key is pinned to one policy; secret values are shown only once.

NEW CREDENTIAL

Name and bind the integration

A clear label and explicit policy binding make rotation and review safer later.

Description Policy

ACTIVE AND REVOKED

Application credentials

Description	Policy	Prefix	Created	Last used	Status
Sign in to manage keys.

DEVELOPER REFERENCE

Build through the safety layer.

Use Ginjo as the OpenAI-compatible base URL in an existing client. Every request is authenticated, checked against application policy, screened, and traced before model-provider egress.

OpenAPI 3.1

API v1 OpenAI-compatible · JSON + SSE

One production origin. Your policy stays in front.

Raw HTTP requests use the origin below. OpenAI SDKs use the same value with /v1 appended.

https://www.ginjo.ai

1
Create a policy-bound API key
Sign in, choose the policy for this integration, and copy the one-time gjo_live_… value.
2
Set it on your server
Store it as GINJO_API_KEY. Never ship the key to browser code.
3
Send an OpenAI-shaped request
Start with the auto alias and inspect the Ginjo response headers.

cURL · Chat Completions

curl https://www.ginjo.ai/v1/chat/completions \
  -H "Authorization: Bearer $GINJO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "auto",
    "messages": [
      {"role": "user", "content": "Explain least privilege in two sentences."}
    ]
  }'

01

AUTHENTICATION

Bearer keys, pinned to one policy

Send the generated key in every model and models request. Ginjo stores only a hash, shows the secret once, and enforces the named policy selected when the key was created. Rotate the key to move an integration to another policy.

Authorization: Bearer $GINJO_API_KEY

Server-side only. A Ginjo API key can spend model budget and must not be embedded in a public web or mobile bundle.

02

REST API

Endpoints

GET/v1/modelsList allowed models

Returns Ginjo aliases and provider models permitted by the current application policy.

POST/v1/chat/completionsCreate a chat completion

Requires a string model and a non-empty messages array. Set stream: true for server-sent events.

POST/v1/responsesCreate a response

Requires model and input. Supports OpenAI Responses tools when the application policy allows them.

GET/health/readyRead deployment readiness

No authentication required. Returns 200 when required gateway dependencies are ready, otherwise 503.

autoRoute according to your Ginjo policy.

efficientPrefer the configured efficiency tier.

capablePrefer the configured capability tier.

Aliases are stable Ginjo names; their underlying provider models can evolve. Call GET /v1/models for the current policy-visible set.

03

OPENAI CLIENTS

Change the base URL, keep the SDK

JavaScript · Responses

import OpenAI from "openai";

const ginjo = new OpenAI({
  apiKey: process.env.GINJO_API_KEY,
  baseURL: "https://www.ginjo.ai/v1",
});

const response = await ginjo.responses.create({
  model: "auto",
  input: "Write a safe rollout checklist.",
});

console.log(response.output_text);

Python · Chat Completions

import os
from openai import OpenAI

ginjo = OpenAI(
    api_key=os.environ["GINJO_API_KEY"],
    base_url="https://www.ginjo.ai/v1",
)

completion = ginjo.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Say hello."}],
)

print(completion.choices[0].message.content)

cURL · Stream Responses over SSE

curl --no-buffer https://www.ginjo.ai/v1/responses \
  -H "Authorization: Bearer $GINJO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"auto","input":"Give me three launch checks.","stream":true}'

04

OBSERVABILITY

Read the decision without parsing the body

Successful model responses preserve the upstream OpenAI-shaped body and add Ginjo metadata as HTTP headers.

HeaderMeaning

x-ginjo-trace-idServer-generated request identity for support and trace lookup.

x-ginjo-verdictGuard finding: PASS, REWRITE, BLOCK, or ESCALATE.

x-ginjo-enforced-verdictDecision actually enforced after policy mode and rewrite revalidation.

x-ginjo-policy-idNamed policy attached to the API key and enforced for this request.

x-ginjo-rewrittentrue when Ginjo safely changed the admitted request.

x-ginjo-risk-scoreOptional normalized guard risk score from 0 to 1.

x-ginjo-selected-modelActual routed provider model when a model call occurred.

x-ginjo-routing-rationaleOptional provider routing summary.

PASSAdmitted and routed.

REWRITEChanged, re-screened, then routed.

BLOCKRejected before provider egress.

ESCALATEHeld for additional review.

05

FAILURE SHAPE

OpenAI-style errors with a trace ID

Example policy rejection

{
  "error": {
    "message": "Request blocked by application safety policy.",
    "type": "policy_error",
    "param": null,
    "code": "policy_blocked"
  },
  "trace_id": "1f64c2c2-…"
}

400Invalid JSON or required request fields.

401Missing, invalid, expired, or revoked API key.

403Application policy blocked or held the request.

413Request exceeds the deployment body limit.

429Hosted request quota reached; respect Retry-After.

503/504Required safety or model dependency unavailable.

Hosted trial limits: 5 admitted requests per minute and 25 per day, per workspace. Safety-blocked requests do not reserve model quota.

DECISION EVIDENCE

Request traces

Security verdicts, routing choices, and timings. Payloads stay excluded unless retention is explicitly enabled.

Verdict Tenant Rows

Not loaded

Total—

Passed—

Rewritten—

Blocked—

Escalated—

Time	Verdict	Risk	Issues	Selected route	Status	Latency	Trace
Connect to load decision evidence.

Overview

See every decision before it reaches a model.

System health

Recent verdicts

Latest test runs

Policy studio

Reusable request policies

Request policy graph

Choose how decisions behave

Models and budget

Tool boundaries

Map findings to decisions

Injection sensitivity

Request limits

Evidence handling

Test lab

Clean request

Ready for a real request

Evaluating request

Running scenarios…

Run history

Gateway API keys

Name and bind the integration

Application credentials

Build through the safety layer.

One production origin. Your policy stays in front.

Bearer keys, pinned to one policy

Endpoints

Change the base URL, keep the SDK

Read the decision without parsing the body

OpenAI-style errors with a trace ID

Request traces