One gateway. Every model. Budgets that hold.
Zimac Gateway puts every model your org uses behind one endpoint and one set of per-user tokens — Anthropic, OpenAI, Bedrock-fronted, Azure, any compatible upstream. The real provider keys live server-side and never reach a laptop; every call lands on a seat and an org with budgets enforced before the provider is reached, metering you can bill from, and failover that kicks in before the first byte. One Rust binary. It powers the Zimac desktop app — and it works with any Anthropic- or OpenAI-SDK client you already have.
client = Anthropic(
base_url="https://proxy.zimac.ai",
api_key="zmc-your-seat-token", # not a provider key
)
client.messages.create(
model="claude-sonnet-4-6", ...
) # prompt caching & tools pass through verbatim
client = OpenAI(
base_url="https://proxy.zimac.ai/v1",
api_key="zmc-your-seat-token", # same token
)
client.chat.completions.create(
model="gpt-5", stream=True, ...
) # metered, budgeted, failover-protected
Both wires. Verbatim.
Point your existing SDK at the gateway and swap the key for a per-user token. Each endpoint speaks its provider's native wire and forwards your request body untouched — no translation layer between you and the model.
| Endpoint | What it does |
|---|---|
| POST /v1/messages | Anthropic Messages API, streaming SSE. Forwarded verbatim to Anthropic-protocol upstreams — prompt-cache breakpoints, tool definitions, and new provider features survive untouched. |
| POST /v1/chat/completions | OpenAI Chat Completions API, streaming SSE. Same tokens, budgets, entitlements, metering, and failover — forwarded to OpenAI-protocol upstreams (OpenAI, Azure, compatible endpoints). |
| POST /v1/embeddings | OpenAI-compatible embeddings, metered and budgeted like everything else. |
| GET /v1/models | The models this caller's org is entitled to — the picker your app renders. |
| GET /v1/budget | The caller's own live spend: seat sub-cap, org pool, prepaid credits, resets. One probe powers a budget bar. |
| GET /v1/prices · /metrics | The effective USD rate table debits are computed from, and Prometheus metrics: per-org/seat/model tokens and cost, TTFT and latency histograms, budget blocks, failovers. |
All /v1/* routes require a per-user bearer token. Ops routes (/healthz, /readyz, /admin) come along for free.
Everything around the call, handled.
The model call is the easy part. What teams actually need is the control plane around it — credentials, budgets, accounting, routing, and operations that hold up in production.
Per-user tokens, revocable live
No shared provider keys in laptops, CI, or notebooks. Every caller gets a zmc- token that resolves to an org and a seat; mint, edit, and revoke from the admin console with changes honoured across the fleet in ≤60 seconds. Secrets are stored as digests, shown once.
Budgets enforced, not observed
Each request's maximum cost is reserved before the provider is reached, then settled from actual streamed usage. Seat sub-caps, org pools, and a durable prepaid-credit floor hold across replicas — an exhausted budget is a clean 402, not a surprise invoice.
Metering you can bill from
A zero-buffer stream meter sniffs usage as bytes flow past — including the cached/uncached prompt split on both wires — and prices it against a published, overridable rate table. Per-org, per-seat, per-model tokens and USD at /metrics, ready for chargeback.
Routing & pre-first-byte failover
Pin any model id to its own upstream — Bedrock for one, Anthropic direct for another, Azure OpenAI for a third — with a fallback model that takes over on 429/529/5xx or an unreachable upstream before the first byte streams. Cost is attributed to the model actually served.
Model entitlements per org
Give each org exactly the model list it may call — enforced on every request and reflected in /v1/models, so a tenant can't discover or invoke what it isn't entitled to. Rate limits are per-seat token buckets, isolated per org.
Operations, done properly
Streaming-safe rollouts (lameduck drain lets long generations finish through a deploy), TTFT and latency histograms per route and model, k8s probes, a distroless non-root image, Helm chart, and Terraform. A Cognito-gated admin console ships in the binary.
“Why not LiteLLM?” Different bet.
Translation gateways rewrite every provider into one API shape. That's convenient — until the rewrite is what breaks. Zimac Gateway bets the other way: protocol-true forwarding, with the enterprise plane as the product.
No translation layer to lag
Your request body is forwarded verbatim to a same-protocol upstream — never mapped through an internal common format. Prompt-cache breakpoints, tool schemas, and day-one provider features work the day they ship, because there is no compatibility matrix sitting in the middle.
One static binary
Rust + axum, distroless, non-root, no interpreter and no database required to start. Budgets and rate limits run in-process; durable credits and the token registry are a single on-demand DynamoDB table when you want them. It deploys like infrastructure because it is.
Money is the first-class object
Most gateways meter after the fact. This one reserves each call's maximum cost up front, settles from streamed usage, and refuses when the org's prepaid balance can't cover it — the same guarantee whether one replica is running or twenty. Finance and enforcement read the same ledger row.
Hosted in minutes. Or entirely yours.
Zimac Gateway — hosted
Create a free account, invite your org, mint seat tokens, top up prepaid credits through Stripe — a $20 top-up lands as $20 of shared budget. No per-seat fee, no markup schedule surprises: the published rate table is the one the meter uses.
Create an accountSelf-hosted
The same gateway, installed in your own AWS account alongside the rest of the Zimac platform — your provider keys, your traffic, your metrics, never touching ours. Flat annual, unlimited seats.
See Zimac EnterpriseQuestions, answered plainly.
Which providers and SDKs does it support?
The gateway exposes both the Anthropic Messages API (/v1/messages) and the OpenAI Chat Completions API (/v1/chat/completions), plus OpenAI-compatible embeddings and model listing. Behind them it fronts any Anthropic-protocol upstream (Anthropic direct, Bedrock-fronted) and any OpenAI-protocol upstream (OpenAI, Azure OpenAI, compatible endpoints). Existing Anthropic and OpenAI SDK code works by swapping the base URL and using a per-user gateway token.
How is this different from LiteLLM?
LiteLLM translates every provider into one OpenAI-shaped API. Zimac Gateway is protocol-true: each endpoint forwards your request verbatim to a same-protocol upstream, never through a translation layer — so prompt caching, tool definitions, and new provider features work the day the provider ships them. It's also a single static Rust binary with budgets, prepaid credits, and billable metering built in, rather than a Python service plus a database.
How do billing and budgets work?
Every token resolves to an org and a seat. Each call's maximum cost is reserved before the provider is reached, then settled from streamed usage; seats have sub-caps, orgs have pooled caps over fixed windows, and a durable prepaid-credit balance is the hard floor across replicas. Over-budget callers receive a clean 402, and per-org, per-seat, per-model token and USD metrics are exported for chargeback. Card details never touch Zimac.AI servers — payments run on Stripe.
Does it translate between Anthropic and OpenAI formats?
Deliberately not. A model routed to an OpenAI-protocol upstream is served on the OpenAI endpoint, and a request for it on the Anthropic endpoint gets a clear 400 naming the right one. Verbatim forwarding is the guarantee that makes provider features work unmodified; if you need one client speaking to both, the SDKs make the base-URL-per-model split a few lines.
Can I run it myself?
Yes. The gateway ships as a distroless container with a Helm chart and Terraform, and it's included in Zimac Enterprise — the one-click install of the whole Zimac platform into your own AWS account, where your keys and traffic never touch Zimac's infrastructure.
Is this the same thing the Zimac app uses?
Exactly the same service — the Zimac desktop and iPhone apps are its first tenants. That's the point: it's proven daily by a real product, and everything the app gets (budget bars, model entitlements, prepaid credits) your own clients get through the same API.
Give every seat a token. Keep every key at home.
Create a free account, mint a token, and point your existing SDK at the gateway — hosted today, self-hosted in your own cloud whenever you're ready.
Get started with Zimac Gateway Self-host it