Point your OpenAI SDK here. The spend cap is already on.
Change two lines and your AI traffic runs through a gateway that meters every token and is allowed to refuse. Route to Claude on our key, to your own keys across 11 providers at zero markup, or to any endpoint you host — all on the Parsons project key you already have.
One subscription covers every Parsons product, in unlimited projects.
{"error":{
"message":"monthly managed spend cap reached ($5.00)
— raise it via the admin MCP (set_spend_cap)",
"type":"insufficient_quota",
"code":"spend_cap_exceeded"}}
Nothing was down. Something was running.
An AI feature doesn't fail the way the rest of your stack fails. It doesn't throw, it doesn't page you, and it doesn't stop. It retries, it re-reads a long context, it loops — and every attempt is billable. Your health check stays green the entire time, because from the outside nothing is broken.
A gateway that is allowed to say no.
Dashboards observe. This one intervenes. Every managed request walks five checks before a single byte reaches a provider, and any one of them can end the request with a status code your client already knows how to read.
per project
per project
is the caller
→ caps → balance
strongly consistent
When a check refuses, the provider is never called. There is no token to pay for and nothing to ask for a refund on.
Distinct codes on purpose: a client can tell "out of quota" from "provider is down" and stop retrying into a wall.
The model string decides everything.
There is no second endpoint, no routing config file and no proxy to stand up. The gateway reads {provider}/{model} and resolves the route in that order: a registered endpoint slug of yours wins, then a provider you've stored a key for, then our managed allowlist.
Mix all three in the same project, from the same key, in the same afternoon.
An unknown model on the managed path returns 404 model_not_found — we refuse to serve what we can't price.
Six models, priced in the open.
The zero-setup path, and we'd rather show you the whole catalogue than imply it's bigger than it is. Managed routing serves Anthropic only. Everything else on earth reaches this URL through your own key or your own endpoint.
| Model id | Provider cost, input | Provider cost, output | You pay |
|---|---|---|---|
| anthropic/claude-fable-5 | $10.00 / 1M tok | $50.00 / 1M tok | × 1.5 |
| anthropic/claude-opus-5 | $5.00 / 1M tok | $25.00 / 1M tok | × 1.5 |
| anthropic/claude-opus-4-8 | $5.00 / 1M tok | $25.00 / 1M tok | × 1.5 |
| anthropic/claude-sonnet-5 | $3.00 / 1M tok | $15.00 / 1M tok | × 1.5 |
| anthropic/claude-sonnet-4-6 | $3.00 / 1M tok | $15.00 / 1M tok | × 1.5 |
| anthropic/claude-haiku-4-5 | $1.00 / 1M tok | $5.00 / 1M tok | × 1.5 |
Managed calls are billed at provider cost × 1.5 and drawn from a prepaid balance — not invoiced after the fact. That multiple is the price of using our key, our contract and our gate with nothing of your own to set up. The moment it stops being worth it, store your own key and the multiple goes to zero. Old model ids stay listed rather than silently redirecting: dropping one would be a hard 404, never a quiet downgrade.
Eleven providers. Zero percent.
Store a provider key once and that provider routes on your account. We add no markup to the tokens and draw nothing from your wallet — but we still meter every request, still enforce your rate limit, and still show you the same per-key breakdown and full request log as managed traffic.
If you already have provider contracts, this is the whole product: routing, key custody, metering and attribution, with the inference bill untouched.
OpenRouter is on that list. One stored key and every model OpenRouter carries becomes addressable through this URL — with nothing taken by us on the way past.
If it speaks OpenAI, it gets a slug.
Register any OpenAI-compatible base URL under a name of your choosing. From that moment it is a model id on the same endpoint, with the same key, the same logs and the same request-id — indistinguishable from every other route to the code calling it.
Self-hosted vLLM, an inference box in your own VPC, a studio deployment, a colleague's fine-tune. Anything you can reach, you can address here.
Provider names are rejected at registration, so a slug can never shadow a real provider prefix.
The managed six are listed by id, because we price them. A key or an endpoint you brought is listed as a wildcard — openai/* — because every model behind it is yours to name, and we're not going to pretend to curate a catalogue we don't maintain.
Your stream, byte for byte.
A gateway that buffers your response to count it has taken your first-token latency and spent it on bookkeeping. This one doesn't. The upstream body is split in two: your client gets an untouched pass-through, and the second branch is read for usage after your response has already finished.
You never set stream_options — on the managed and BYOK paths the gateway asks the provider to include usage on your behalf, and peels it off where you can't feel it.
Tracks A and B land in the same frame because they are the same bytes. Track C is the usage row, the spend counter and the billing event — all after the response is closed.
Which caller spent the money.
One provider key gives you one total. Here you mint a named key per caller — prod-backend, ci, nightly-digest — and every request is tagged with the prefix that authenticated it. The console rolls the month up by key, so "what is the nightly job costing us" is a question with an answer rather than a guess.
| label | prefix | requests | in tok | out tok | billed |
|---|---|---|---|---|---|
| prod-backend | sk_live_9f3a… | 18,402 | 4,110,882 | 903,517 | $27.41 |
| nightly-digest | sk_live_2c71… | 744 | 1,982,004 | 122,860 | $9.06 |
| ci | sk_live_be05… | 1,236 | 88,410 | 21,077 | $0.42 |
Every request writes one row, and the row carries all of it:
BYOK and BYOM requests are logged in full too — same columns, same filters — they simply emit no billing event. user_id is the row's slot for an end user and is filled when a call arrives from a signed-in chat session; a request made with a project key over /v1/chat/completions has no signed-in human behind it, so it logs NULL.
Priced the way Anthropic bills it.
If you re-send a long system prompt on every turn, the difference between a gateway that flat-rates your input tokens and one that reads the real cache counters is most of your bill.
We take cache_creation_input_tokens and cache_read_input_tokens straight off the provider's own usage object and re-price them: writes at 1.25× the input rate, reads at 0.10×. Not estimated, not averaged, not rounded to whole input tokens.
A cache write costs 1.25× — you pay a little more once to pay a tenth thereafter.
Drag the slider. The receipt recomputes from the published per-token rates, the same arithmetic the gateway runs.
Keys you can actually kill.
Your Parsons project key is the API key — there is no second credential to invent, exchange or rotate separately. Mint as many named keys as you have callers, with a label of your choosing, and the full value crosses the wire exactly once.
Revocation is by prefix and takes effect on the next request. No grace window, no propagation delay, no "it may take up to 15 minutes".
Twenty tools. No dashboard required.
The whole gateway is addressable from Claude, ChatGPT or Cursor — caps, provider keys, custom endpoints, credits, usage, and a live test completion that runs through the identical routing, gating and metering as production traffic.
Every mutation writes an audit row, including the ones that fail. The console mirrors each tool one-for-one, so it is the same surface either way.
The docs tool serves the same bytes as the public quickstart, so an agent reads the real integration guide instead of guessing at the API. set_auto_reload is on that list and answers by refusing — the rail is parked, and nothing on this platform tops your balance up on its own. grant_credits and set_credit_balance are operator levers that require platform-admin, not project ownership.
We ship on it before you do.
Fourteen production workers bind this service — the apps we sell and the services they run on, named below. Not a reference integration, not a demo project. When the gate is wrong, our own apps stop first.
Our own money app's AI runs through this gate. That is the only trust signal on this page, and it is the one we can actually stand behind.
Six rows here go against us.
A comparison that only flatters the seller is a comparison you can't use. Here is where this gateway is the wrong choice, stated as plainly as where it's the right one.
Rate limit: 300 requests per minute, per project. Upstream timeout: 120 seconds, then a clean 502. Published, because a limit you have to discover is a limit you find out about badly.
One plan, two intervals, and what it actually buys.
The subscription is access — to this gateway and to every other Parsons product, in as many projects as you want. Consumption is separate, prepaid, and capped by you. Past an included allowance you keep going — the overage draws from the same prepaid balance at roughly cost × 1.5. Nothing arrives as a surprise invoice, because nothing is invoiced after the fact.
- Every Parsons product — gateway, auth, database, deploy, storage, email, scheduler and the rest
- Unlimited projects — each with its own keys, members and spend cap
- No monthly request allowance on the gateway — you pay for tokens, not for calls (300 req/min per project)
- The included allowances — Deploy 10M CPU-ms, 1M requests, 1 GB app storage · Database 1 GB, 100M rows read, 1M rows written · Storage 5 GB · Email 200 sends/day · Scheduler 20,000 fires
- Managed spend cap of $5.00 per month per project by default, settable $0–$10,000
- Named keys, per-key spend attribution, and a filterable row for every request
A separate project per business, or one for work and one for yourself — separate data, separate members, separate spend caps, separate keys. Add as many as you like; the number above does not move. There is no workspace tier here, because there is no workspace to sell you.
14-day free trial on your first subscription · cancel any time · pay monthly or yearly — a year costs two months less · no free tier, no per-seat pricing, no enterprise tier
The questions people actually ask.
What happens, exactly, at the cap?
The request stops at the gate. The provider is never called, so there is no token to pay for. Your client receives a standard OpenAI error envelope, which means your existing SDK error handling surfaces it without changes.
Is BYOK really 0%? Including a fee to fund the account?
Yes. A BYOK or BYOM request is proxied on your key, logged in full, and emits no billing event at all — no markup on the tokens and nothing drawn from your prepaid balance. There is also no percentage taken when you top that balance up; a $20 top-up puts $20 on the balance.
The subscription is what pays for the routing, the key custody, the metering and the attribution.
Which models are on managed, and what's the markup?
Six, all Anthropic: claude-fable-5, claude-opus-5, claude-opus-4-8, claude-sonnet-5, claude-sonnet-4-6, claude-haiku-4-5. Managed calls bill at provider cost × 1.5 — with BYOK always available at 0%. Anything outside that list on the managed path returns 404 model_not_found rather than being served at a price we can't compute.
Do you buffer my stream?
No. The upstream body is teed: your client gets one branch untouched, and usage is read from the other after your response has closed. You don't set stream_options — the gateway adds include_usage upstream so the metering branch has something to peel.
What's the rate limit?
300 requests per minute, per project, on /v1/chat/completions. Exceeding it returns a 429 with the OpenAI rate_limit_error type and the limit stated in the message.
Do I need a second API key?
No. Your Parsons project key — sk_live_… — is the API key. Pass it as a Bearer token, or as apiKey in any OpenAI SDK. You can mint additional named keys per caller for attribution and revocation, but they're the same kind of credential, issued by the same account.
What happens if the provider hangs?
Each upstream model call is bounded at 120 seconds. A timeout or an unreachable provider returns a clean 502 upstream_error rather than hanging until the platform's own wall clock kills it. Every response that reached the provider — the successes and the upstream failures alike — carries an x-request-id header for support. A request the gate refuses never got that far; it is identified by its error code instead.
Can I self-host it?
No. This runs on our infrastructure and there is no distribution you can deploy yourself. If self-hosting is a requirement, an open-source proxy is the right answer for you — just count the database, the cache and the on-call rotation as part of its price.
Can I delete my data?
Yes, and it's wired to account deletion rather than being a support ticket. The service exposes an internal purge that the platform's deletion orchestrator calls, erasing this service's rows for your project. Every read and write is project-scoped in the first place, and provider keys are AES-256-GCM encrypted at rest.
Is any of it free to keep using?
No — the trial, then you pay. The subscription is $15 a month or $150 a year; the yearly price is the monthly one with two months taken off. Your first subscription starts with a 14-day free trial you can cancel any time, and checkout does collect a payment method; we'd rather say that here than surprise you at the form. A one-time $2 starter credit is seeded on first managed spend so the models work immediately.
Two lines to point at it. One line to stop it.
$15/mo or $150/yr · 14-day free trial, cancel any time · every product, unlimited projects.