AI Gateway
Routers route. This gateway proves.
One URL in front of every model call. Routing, failover, and spend like the gateways you know, plus guardrails that are on by default and a signed receipt for every response that anyone can verify offline.
OpenAI compatible · 15+ providers by name · receipts verify offline
from openai import OpenAI
client = OpenAI(
base_url="https://app.axiorank.com/api/proxy/v1",
api_key="sk-...", # forwarded, never stored
default_headers={"X-AxioRank-Key": "axr_live_..."},
)Every response returns
"receipt": { "kind": "axiorank-action-passport-v1",
"decision": "allow", "signature": "..." }Live
Send a real prompt through a real gateway.
This is not a mock. Your prompt runs on the production pipeline against a sandboxed workspace: real detectors, a real routing decision, and a real Ed25519 signed receipt at the end. Verify it right here, or take the JSON and verify it offline where we cannot touch it.
Universal
No rewrite. Just a new address.
Your apps already speak the provider APIs. The gateway speaks them too, so adoption is a base URL plus one header. The provider key keeps riding in the request, forwarded for that one call and never stored.
OpenAI and Azure
Chat Completions and the newer Responses surface. Point base_url at the gateway and call as usual.
Anthropic Messages
Your Anthropic key keeps riding in x-api-key, forwarded for that one call and never stored.
OpenRouter
Reach hundreds of models through one upstream, all governed by the same ladder.
Amazon Bedrock
Converse and ConverseStream. The gateway re-signs with SigV4 from your AWS credentials.
Google Gemini
The native generateContent and streamGenerateContent API, model and method in the path.
Any OpenAI-compatible endpoint
27 named presets, from Groq and Cerebras to Qwen and GitHub Models, or any base URL that speaks the OpenAI shape. Browse the model catalog for everything they reach.
Reliability
One alias. Any provider. No single point of failure.
Point an app at one alias instead of a single model. The gateway picks the target by your policy, spreads load, and fails over when an upstream is rate-limited or down, so a provider outage degrades to a fallback instead of an error.
Dynamic routing
An alias like axio/auto fans out to an ordered list of provider and model targets. Route to the cheapest by the price catalog, a priority order, or your own weighting.
Failover
A rate limit, timeout, or 5xx from one target transparently fails over to the next, so reliability does not hinge on one provider staying up.
Load balancing
Weighted round-robin spreads traffic across providers and keys, so no single upstream or quota becomes the bottleneck.
Retries with backoff
Transient upstream errors are retried with exponential backoff before the gateway gives up or fails over.
Response caching
A semantic cache returns a known-good answer without a round trip, cutting cost and latency on repeat prompts.
Guardrails
Four outcomes, on the prompt and the answer.
Other gateways make guardrails a plugin you configure later. Here the ladder runs on every call from the first request. The prompt is governed before the model is called; the completion is governed before it reaches your app.
Allow
Clean on both sides. The provider response is returned unchanged, and usage is metered.
Deny
A live secret or a blocked destination in the prompt returns a 403 and the model is never called.
Hold
A risky prompt returns a 409 with an approval id, so a human clears it before the model runs.
Redact
Secrets and PII in the answer are masked in place, with every other field of the response preserved.
Proof
Every response ships with proof.
A router can tell you which model answered. It cannot prove the answer was governed. Every response through the gateway carries a signed Action Passport that binds the decision, the matched policy, the risk score, and the delegation chain to that exact call.
What the seal binds
The decision, the policy that matched, the risk score, and the full delegation chain, hashed into one Ed25519 signature.
$ npx @axiorank/audit-verify \
passport receipt.json
✓ format recognized
✓ signature verifies
✓ provenance binds to this callLogs say what you claim happened. Receipts prove it.
Open source
The same gateway, on your laptop.
Run the gateway locally with one command. Local guardrails and signed receipts, no account required. When you want approvals, a transparency log, and dashboards, the same URL points at the cloud.
$ npx @axiorank/gateway gateway listening on http://localhost:8787 guardrails on · signed receipts on
Open source, on your laptop
- Local guardrails on every call
- Signed receipts you can verify offline
- Routing, failover, and load balancing
Cloud adds
- Managed policies and human approvals
- A sealed transparency log and a semantic cache
- Spend dashboards and cross-team observability
The field
They route. We prove.
Routing and failover are table stakes. The gap is what happens to safety and evidence on every call.
| Capability | Routers | AxioRank |
|---|---|---|
| Routing and failover | Everyone | Yes |
| Guardrails on by default | Configure later | On from the first call |
| Signed receipt per response | None | Only AxioRank |
Questions
Answers before you point a URL at it.
Is the gateway OpenAI compatible?
Yes. Point your OpenAI or Azure client at the gateway base URL and add one header. Your chat.completions and Responses calls work unchanged. Anthropic, Bedrock, and Gemini are governed through the same URL with their native shapes.
Which models and providers can I reach?
27 named presets cover Anthropic, Google, Groq, Cerebras, SambaNova, NVIDIA, Hugging Face, GitHub Models, Qwen, Kimi, GLM, and more, next to native OpenAI, Azure, and Bedrock support; OpenRouter adds hundreds more; and any OpenAI-compatible base URL works as a custom upstream. The model catalog at axiorank.com/models lists every cataloged model with prices and a copy-paste snippet.
Do you store my provider key?
No. The provider key rides in the request, forwarded for that one call and never persisted. On Enterprise you can store a key once, encrypted at rest, so callers send only the AxioRank key.
What does the receipt prove?
Each response carries a signed Action Passport that binds the decision, the matched policy, the risk score, and the delegation chain to that exact call. It is signed with Ed25519 against a public key, so anyone can confirm the response was governed.
Can I verify a receipt without trusting AxioRank?
Yes. Take the receipt JSON and run npx @axiorank/audit-verify against our published key, offline, on your own machine. The proof holds even if our service is down and even against us.
How is this different from Portkey and other routers?
Routers give you routing, failover, and load balancing. So do we. The difference is that guardrails are on by default from the first request, and every response ships with a signed receipt anyone can verify offline. Routers route. This gateway proves.
Keep exploring
Continue across the control plane.
Point one URL at the gateway and get proof back.
Change one base URL, add one header, and get routing, failover, guardrails on by default, and a signed receipt for every response.