model.cards
Get started

Pricing

Your keys. Your rates. Our routing.

model.cards never resells tokens. You connect your own provider keys, your providers bill you at your own rates, and the gateway earns its keep by sending each request to the lightest model that can handle it. Free during beta.

Free

Everything, free
$0
during beta, no card ever

The whole product. Connect your provider keys, point your SDK at one endpoint, and let complexity routing pick the right model per request.

  • Bring your own provider keys — 8 providers supported
  • modelcards/auto complexity routing
  • Up to 25 API keys, each with its own spend guardrail
  • Usage log with per-request cost estimates
  • Failover across providers when an endpoint errors
  • Full model cards, rankings and pricing data
Start free

Pro

Coming soon
$19
per month, flat — a subscription, never a token markup

For teams that want more control over the loop. Priced as a subscription so our incentive stays routing you cheaper, not billing you more.

  • Routing analytics: savings vs. an always-frontier baseline
  • Higher rate limits and longer usage-history retention
  • Advanced routing policies as they land
  • Priority support

Join now to lock in beta pricing when Pro launches.

Enterprise

Let’s talk
design partnership, during beta

We are taking on a small number of design partners while the platform is in beta. Bring the requirements your procurement team will not bend on and we will scope what it takes to meet them.

  • Org accounts with shared provider keys and per-member quotas
  • SSO on the roadmap; tell us your provider
  • DPA and security review handled case by case
  • A named contact and a shared channel
  • Direct input on what we build next
Talk to us

Flat fee vs. a cut of your spend

A percentage grows with your bill. $19 doesn’t.

Pro is a flat $19/mo. Most gateways instead take a percentage of everything you route through them — which quietly scales the more you use them.

What a ~5% cut costs, by monthly spend

One shared axis, so the flat fee stays put while the percentage climbs.

at $1,000/mo
save $31
at $5,000/mo
save $231
at $10,000/mo
save $481
model.cards, flat $19extra a ~5% gateway adds

Priced to route you down, not up

  • A router paid a cut of your spend earns more when you spend more. Ours is flat, so it’s the only one with a reason to route you to a cheaper model — and the saving lands on your provider bill, not ours.
  • Complexity routing lowers that provider bill underneath the fee, so the saving lands twice: no percentage on top, and a smaller invoice from the provider that served the request.
  • No balance to top up and no credits held as float. Your provider bills you directly, so no one is sitting on your money between requests.

Gateways that route on your behalf commonly take around 5% of what you spend. OpenRouter, for example, charges roughly 5.5% on credit top-ups (with about a $0.80 minimum) and holds those credits as float, plus a BYOK fee once you pass ~1M requests a month. In fairness the other way: below about $345/mo of spend a 5.5% cut is already less than $19 — and there our free tier beats paying any percentage at all.

Where the money goes

A closed loop, with you and your providers

There is no balance held here and no fee added per token. The loop is: your request comes in, the router scores it, your provider key serves it, your provider bills you, and the outcome tunes the next routing decision.

Bring your own keys

  • Connect keys for Anthropic, OpenAI, Google, Groq, Together, Mistral, DeepSeek or xAI on the Providers page.
  • Providers bill you directly at your account's own rates — negotiated discounts and credits apply unchanged.
  • Keys are AES-256-GCM encrypted at rest and never leave the server unencrypted.
  • Per-key spend guardrails stop a runaway loop before it runs up your provider bill.

Complexity routing pays for itself

Most production traffic is a mix: greetings, reformatting and simple extraction next to genuinely hard reasoning. Sending all of it to a frontier model means paying frontier prices for easy tokens. modelcards/auto scores each request and routes it to the lightest model that can handle it — so the expensive model only sees the requests that deserve it, and the savings land on your own provider bill.

Every auto-routed response reports the tier, the complexity score and the estimated cost in its x_modelcards block, so the decision is auditable per request.

FAQ

Questions we get before the first key is connected

What do I actually pay?
Your providers, and only your providers. Requests run on the API keys you connect, so your providers bill you directly at whatever rates your account has. model.cards is free during beta and adds no markup — there is no balance to top up and no invoice from us.
How does model.cards make money, then?
The paid tier will be a flat subscription for advanced routing controls and analytics. We deliberately do not resell tokens: a router paid per token has an incentive to route you expensively, and we want the opposite incentive.
How does complexity routing decide which model gets my request?
Every request to modelcards/auto is scored for complexity — length, code, reasoning demands, conversation depth. Light requests go to fast, cheap models; hard ones escalate to frontier reasoning models, always within the providers you have connected. The router also reads your own recent usage log: a model that has been failing for you is routed around automatically. See routing in the docs for the exact behaviour.
How are my provider keys stored?
Encrypted at rest with AES-256-GCM, decrypted only in memory at the moment a request needs them, never logged, and never shown again after you save them. You can replace or remove a key at any time, and deleting your account deletes the stored keys with it.
What if I have negotiated rates or committed spend with a provider?
That is exactly the point of BYOK: the provider bills your account at your rates. model.cards never sits in the money path, so your discounts, credits and rate limits all apply unchanged.
Is my data used for training?
No. We do not train on your prompts or completions and we do not sell them. Once a response finishes, message content is not retained server-side; what we keep is usage metadata — model id, provider, token counts, timestamps, cost estimates, routing decisions. The privacy policy lists it field by field.
What are the rate limits?
Your providers’ own limits apply, since requests run on your keys. On top of that we run fair-use limits on the gateway itself during beta; we will get in touch before throttling anyone.
What happens if I have no provider key connected?
Requests to real models fail with a clear error, and the free simulator model keeps working so you can exercise your integration end to end. Connect a key on the Providers page and traffic flows immediately — nothing to reissue.

Still deciding? The docs cover the endpoint surface, error codes and routing behaviour in full.

Read the docs