Every AI model.
One place.
One bill.
GPT-5, Claude, Llama, DeepSeek and 293 more — all reachable from one account, at what the route costs us and not a cent more. Compare them side by side, see what every answer costs, and set a limit you cannot go past.
No card to sign upNo subscriptionRun out and it stops, never a surprise bill
- 297
- models
- 6
- providers
- 29
- with automatic failover
What 1,000 questions cost
live pricesEach roughly 375 words in and 225 out — a paragraph of context and a solid answer.
- Ling-2.6-flashcheapest in the catalogue$0.0140
- Qwen3.5 Plus 2026-04-20a middle option$0.7280
- o1-prothe most capable$269.03
Same question, same account, same bill. Switching between them is one word — and whichever you pick, we add no spread of our own to the rate.
Prefer code? It's the OpenAI SDK with one line changed
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.multigrid.ai/v1",
apiKey: process.env.MULTIGRID_API_KEY,
});
const res = await client.chat.completions.create({
model: "multigrid/auto", // or any model id in the catalogue
messages: [{ role: "user", content: "Summarise this contract." }],
// Multigrid-only. An ordinary OpenAI SDK ignores these.
models: ["anthropic/claude-sonnet-5"], // fallback chain
provider: {
order: ["groq", "together"], // prefer these
ignore: ["deepinfra"], // never these
sort: "price", // cheapest route first
},
});
// res.multigrid.cost_usd — what this exact call cost you.One key reaches every one of these
Three steps, no installation
You can do all of this in a browser. Writing code is optional, and it comes later.
- Step 1
Make an account
No card. You start at a zero balance, which means nothing can be charged until you decide to add credit.
- Step 2
Ask something
Add credit, or paste a provider key you already have — then type a question into the Playground and pick a model. The answer comes back with the price of that exact answer next to it.
- Step 3
Set your ceiling
Choose the most you are willing to spend in a month. Past it, requests stop with a clear message — they never become a bill.
What you get that going direct does not
Anyone can forward your question to a model and bill you for it. The useful part is what happens around that: keeping the bill visible, carrying on when a provider breaks, and letting you change your mind about which model you use.
Your own provider keys, at 0%
Add an OpenAI or Anthropic key and that traffic costs you nothing here. We still route it, fail it over, meter it and log it — we just do not bill for tokens you already pay someone else for.
Learn moreFailover across providers
Many models are served by more than one provider. When the first returns a 429 or a 5xx we move down the list mid-request. Any other 4xx is your request's own fault and is handed straight back rather than retried everywhere.
Learn moreMetering you can audit
Every request returns exactly what it cost, in integer micro-dollars, computed from the tokens the provider reported. The ledger is append-only, and an audit re-derives every balance from it rather than trusting the running total.
Learn moreRetries that cannot double-bill
Send an Idempotency-Key and a retry after a network blip replays the stored answer instead of paying for the same completion twice. The claim is taken before we go upstream, so two simultaneous retries cannot both run.
Learn moreChange the model without a deploy
Save a model, system prompt and parameters as a preset, then call it by name. Retuning production becomes an edit in a dashboard rather than a release.
Learn moreBudgets that actually refuse
Per-key spend caps, per-key rate limits and an account ceiling, all checked before anything reaches a provider. A key leaked in a mobile binary cannot drain the balance.
Learn moreCompare every model on price and context
Read from the same rows the gateway bills against, so this cannot quietly disagree with an invoice. Latency and throughput are not here — we have not served enough traffic to measure them honestly, and /models says so too.
| Model | Input / 1M | Output / 1M | Context |
|---|---|---|---|
| Ling-2.6-flashinclusionai/ling-2.6-flash | $0.011 | $0.032 | 262K |
| Mistral Nemomistralai/mistral-nemo | $0.020 | $0.032 | 131K |
| Llama 3.1 8B Instructmeta/llama-3.1-8b-instruct | $0.020 | $0.040 | 131K |
| Llama 3 8B Lunarissao10k/l3-lunaris-8b | $0.042 | $0.053 | 8K |
| MythoMax 13Bgryphe/mythomax-l2-13b | $0.063 | $0.063 | 8K |
| Mistral Small 3mistralai/mistral-small-24b-instruct-2501 | $0.053 | $0.084 | 33K |
| Gemma 3 4Bgoogle/gemma-3-4b-it | $0.053 | $0.105 | 131K |
| Granite 4.1 8Bibm-granite/granite-4.1-8b | $0.053 | $0.105 | 131K |
Say which providers you trust. We do the rest per request.
Routing is a few optional fields on the request an ordinary OpenAI SDK passes straight through — no policy language to learn, and nothing to deploy separately from the code that sends the request.
- Fallback chainsList models in order. If the first cannot be served — no route, no key, a 429 or a 5xx — we move to the next before a token is emitted.
- Provider preferencesorder to try these first, ignore to never use them, sort by price, latency or throughput. A provider you exclude is excluded even under load.
- Per-request cost ceilingsA max_cost guardrail refuses a request whose worst case exceeds the cap, before anything is sent upstream and before it is priced.
- Cheapest that fitsmultigrid/auto picks the least expensive model that can actually do the job — fits the prompt, supports the features asked for, and has a key. A rule you can predict, not a guess at how hard your prompt is.
{
"model": "anthropic/claude-sonnet-5",
"models": ["openai/gpt-5", "meta/llama-4-70b"],
"provider": {
"order": ["anthropic", "bedrock"],
"ignore": ["deepinfra"],
"sort": "price",
"allow_fallbacks": true
},
"messages": [{ "role": "user", "content": "..." }]
}What you get back
The response carries the model and provider that actually served the request, every hop that was tried before it, and the exact cost in integer micro-dollars. Nothing about the route is inferred after the fact — it is recorded as it happens.
The same question, 19216× apart
Picking the right model for the job is the single biggest lever on an AI bill — far bigger than anything a gateway can do behind your back. So we show you the prices and let you choose.
All three answer the same question. Which one is worth it depends entirely on what you are asking — and you can try them side by side before you decide.
Honest about where we win
If you only need one vendor, go direct — it is cheaper, because we resell at cost and then charge 5% at top-up. That is truest for a model we reach through OpenRouter, where their fee sits under ours and we cannot beat them on price. The moment you have two models, a budget and a pager, this table starts to matter.
| Capability | Multigrid | Direct to vendor |
|---|---|---|
| Our own spread on token prices | None, either way | None |
| Direct providers — OpenAI, Anthropic, Groq, Together, DeepInfra | Their list price | Same |
| Models reached through OpenRouter | Their price + their 5.5% credit fee | N/A |
| Fee on credit top-ups | 5% + $0.35 | None |
| Monthly subscription | No | No |
| Route on your own provider keys | 0% fee | N/A |
| One balance across every vendor | Yes | No |
| Automatic failover between providers | Yes | No |
| Per-request cost in the response | Yes | No |
| Idempotency keys | Yes | Varies |
| Opt-in response cache | Exact match only | No |
| Per-key spend caps | Yes | No |
| Named presets callable from the API | Yes | No |
| Signed webhooks for balance events | Yes | No |
| Guardrails in-path | Yes | Varies |
| Batch queue | Yes — no discount | Varies |
| Semantic caching | No | No |
| Evals and CI gates | Score submission only | Varies |
| Region pinning | No | Varies |
| SSO and SCIM | No | Varies |
| Uptime SLA with credits | No — not while we are this new | Varies |
There is no column here for other gateways. There was one, with eighteen rows of fees and missing features attributed to a competitor, and nobody here had read their terms. We are not in a position to describe someone else’s product accurately, we would not notice when they changed it, and they have no way to correct us — so compare us against them yourself, on their own pricing page.
No certifications. Here is what there is instead.
Multigrid has no SOC 2 report, no ISO 27001 certificate and no penetration test — it launched in 2026 and has not been audited. If your procurement requires one of those, rule us out now rather than in week three. What follows is what the code actually does.
We never train on your data
Prompts and completions are never written to our database, so there is nothing to train on and nothing to leak. Only token counts, latency and which provider answered.
Provider keys encrypted at rest
AES-256-GCM, with the master key in the deployment environment and never in the database. Only the last four characters are ever shown back to you.
An append-only ledger
Your balance is the sum of immutable entries, not a number someone can edit. An audit script re-derives every balance and exits non-zero on any drift.
Spend caps checked first
Per-key and account ceilings are evaluated before anything reaches a provider, so a key leaked in a mobile binary cannot drain the balance.
Pay what the route costs. Pay us once, at top-up.
No spread of ours hidden in the token rate — you pay what the route costs us. Our margin is 5% plus $0.35 for card processing, both separate lines you can audit against a receipt. Route on your own provider keys and both drop to zero.
Pay as you go
Add credit, spend it on any model. That is the whole product.
Plus $0.35 per top-up for card processing.
Create an account- Every model at what its route costs us — no spread of ours
- 5% plus $0.35 per top-up, charged once and itemised — $5 of credit costs $5.60
- Every feature included: routing, caching, guardrails, batch
- Automatic failover and provider preferences
- Request logs, analytics, webhooks and audit trail
- Per-key spend caps and hard account ceilings
Credit never expires and is refundable minus payment processing. No monthly fee, no seats.
Bring your own keys
Use your own provider contracts and pay us nothing at all.
- Your provider keys, your negotiated rates and committed spend
- 0% — no top-up fee, no monthly fee, no percentage on usage
- Keys sealed with AES-256-GCM, never returned to a client
- Mix BYOK and Multigrid credit in one routing policy
- Spill over to our capacity when your quota runs out
- Identical routing, caching, guardrails and audit trail
You pay each provider directly. We only see the metadata needed to route and log the call.
Enterprise
For high volume, and for finance teams that need to talk to a person.
Plus $0.35 per top-up for card processing.
Talk to us- The same gateway — nothing here is locked behind this column
- A top-up percentage below 5%, agreed in writing at volume
- 0% on everything you serve with your own provider keys
- A hard account ceiling, so a pilot cannot overrun its budget
- A direct line to the person who wrote the routing layer
Still a balance, not a subscription — the negotiation is about the percentage, not a licence. SSO, SCIM, data residency and private deployment do not exist yet; ask us before you plan around them.
The questions we actually get
What do you actually charge?
There is no subscription and no monthly fee, and we take no spread of our own on the token rate — ever. You pay what the route costs us. For the five providers we hold a direct key with — OpenAI, Anthropic, Groq, Together and DeepInfra — that is their published price to the cent. Most of the catalogue is reached through OpenRouter instead, and we buy their credit at list plus 5.5%, so those rates carry that 5.5% in them. It is in the number on the model page rather than hidden behind it. Our own money comes from one place: when you top up credit we take 5%, plus a flat $0.35 for what the card processor charges us. On a $5 top-up that is $5.60; on $100 it is $105.35. Bring your own provider keys and every one of those goes to zero.
How hard is it to migrate?
Change the base URL and the API key. We are wire-compatible with the OpenAI SDK, so the vast majority of codebases move in one line. Multigrid-specific features live in optional top-level fields (`models`, `provider`) that an ordinary OpenAI SDK passes through untouched.
What happens when a provider goes down?
Before the first token, we move down your fallback chain — next provider for the same model, then the next model you listed. Once a stream has started we do not silently switch mid-answer; you get an error event on the same stream and every token produced up to that point. The trace shows each hop that was tried.
Do you train on my data?
No. Prompts and completions are never written to our database — only token counts, latency and which provider served the request. You can exclude any provider from your traffic with the routing preferences.
Can I use my own provider contracts?
Yes. Add your provider keys and Multigrid routes through them, so your committed spend and negotiated rates still apply while you keep the routing, caching and observability layer.
What do you store about my requests?
To whichever provider serves the request, and nowhere else. We store token counts, latency and the provider that answered — never the prompt or the completion. Region pinning is not built yet; if you need it, choose providers whose region you already know.
Ask your first question in about a minute.
No card, no installation, and nothing to configure before you see whether this is useful to you. If you write code, pointing an OpenAI client at https://api.multigrid.ai/v1 is the whole migration.
297 models · 6 providers · one bill