Your keys.
The right model, every time.
model.cards is a single OpenAI-compatible endpoint that routes on your own provider keys. Ask for modelcards/auto and each request is scored for complexity, then sent to the lightest model that can handle it — your providers bill you directly, with zero markup.
Free during beta. You pay your providers, never us.
curl https://model.cards/api/v1/chat/completions \
-H "Authorization: Bearer $MODELCARDS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "anthropic/claude-sonnet-4.5",
"messages": [{"role": "user", "content": "Name three CRDTs."}],
"stream": false
}'{
"id": "chatcmpl-8fa2c1d47e0b93a5f218c6e0",
"model": "anthropic/claude-sonnet-4.5",
"provider": "anthropic",
"choices": [
{"message": {"content": "G-Counter, LWW-Register, OR-Set."}}
],
"usage": {"prompt_tokens": 14, "completion_tokens": 17}
}Model and provider counts are read from the catalog on every page load. Bring your own key for 8 of them today.
Trending this week
What developers are shipping with
Ordered by the weekly token volumes on each model card.
Reference data — not yet measured from live traffic
Why a router
Pay frontier prices only for frontier problems
Most traffic is a mix of easy and hard requests. Sending everything to one big model means paying its price for tokens a small model handles fine — the router fixes that per request, on your own keys.
Complexity-based auto-routing
Ask for modelcards/auto and each request is scored — length, code, reasoning demands, conversation depth — then routed to the lightest model that can genuinely handle it. Hard requests escalate to frontier reasoning models automatically.
A loop that learns from your traffic
Every routed request feeds the next decision: models that recently errored for you are routed around, and every response reports its tier, complexity score and estimated cost so the choice is auditable.
Drop-in for OpenAI clients
Point your existing SDK at our base URL and change the model string. Streaming, tool calls and JSON mode use the schema your client already sends, so the rest of your code is untouched.
A model card for every model
Every model has a page with per-provider prices, context limits, throughput and uptime, so you can compare offers before you pick one. Prices come from the catalog; the performance figures are reference data until the gateway has traffic of its own to report.
Spend guardrails per key
Issue a separate key for each service and cap its estimated spend. Limits are enforced at the gateway, so a runaway loop stops at your ceiling instead of running up your provider bill.
Privacy by default
We never train on your prompts or completions, and we don't sell them onward. Once a response completes we keep the usage metadata billing needs — token counts, model id, timestamps, cost — and no message content server-side. Details in the privacy policy.
Migration
Two lines change. Nothing else does.
Keep the OpenAI SDK you already use. Swap the base URL and the key, then let modelcards/auto pick per request — or address any catalog model by its full id.
import OpenAI from 'openai'
const client = new OpenAI({
apiKey: process.env.OPENAI_API_KEY,
})
const res = await client.chat.completions.create({
model: 'gpt-4o-mini',
messages: [{ role: 'user', content: 'Summarise this changelog.' }],
})import OpenAI from 'openai'
const client = new OpenAI({
baseURL: 'https://model.cards/api/v1',
apiKey: process.env.MODELCARDS_API_KEY,
})
// 'modelcards/auto' routes each request by complexity —
// or address any catalog model directly by its full id.
const res = await client.chat.completions.create({
model: 'modelcards/auto',
messages: [{ role: 'user', content: 'Summarise this changelog.' }],
})Full request and response reference lives in the chat completions docs.
Ship with the best model for every request
Connect a provider key, keep your client, and start routing in under five minutes. Free during beta — you pay your providers, never us.