Answer: Enter your token volumes above — monthly API costs per model are calculated and compared live, all locally.
Real-time pricing for 300+ AI models. Compare cost per million tokens, calculate your spend, find the cheapest model for your use case.
| Model | Provider | Input ($/1M) | Output ($/1M) | Context | Blended Cost * |
|---|
* Blended cost assumes 3:1 input-to-output ratio (typical chat workload). Prices are per 1 million tokens. Data sourced live from OpenRouter API. Some models may have additional fees (image processing, tool calls, caching).
LLM APIs charge per token — roughly ¾ of a word. A 1,000-word article is about 1,300 tokens. Most providers split pricing into input tokens (your prompt) and output tokens (the model's response). Output tokens typically cost 3-5× more than input.
Some providers offer batch pricing (50% off for non-real-time requests) and cached input discounts (up to 90% off for repeated prompt prefixes). Always check both input and output rates when comparing models — a cheap input price can hide expensive outputs.
This tracker pulls live pricing from OpenRouter, which aggregates 300+ models across all major providers. Prices update automatically.
Every token an LLM emits gets generated one at a time, each one conditioned on everything before it — that's the expensive pass. Input tokens only get processed once. So a model that reads a 50-page contract and returns a two-paragraph summary charges you heavily for the reading and lightly for the writing, while a chatty chatbot that skims a short prompt and writes an essay is mostly paying output rates. The practical consequence: apps that stuff huge context and expect short answers are input-bound, and apps that generate long content are output-bound. Know which one you're building before you shop on price.
Context length changes the bill too. Several providers now tier their pricing by how much context you use — the same model can quote one rate below a threshold like 200K tokens and a higher rate above it, because long-context requests hit costlier serving paths. If your workload genuinely needs a 1M-token window, compare the long-context rate, not the headline one.
The calculator above defaults to 1 million input tokens and 500,000 output tokens a day — a moderate app feature, not a heavy production workload. Here's what that volume costs on the representative models the calculator ships with, at the rates baked into it:
| Model | Input $/1M | Output $/1M | Daily cost | Monthly cost |
|---|---|---|---|---|
| GPT-4o | $2.50 | $10.00 | $7.50 | $225 |
| GPT-5 | $1.25 | $10.00 | $6.25 | $187.50 |
| Gemini 2.5 Flash | $0.30 | $2.50 | $1.55 | $46.50 |
| DeepSeek V4 Flash | $0.09 | $0.18 | $0.18 | $5.40 |
| Cheapest tracked tier | $0.01 | $0.03 | $0.03 | $0.75 |
Read that spread twice. The identical workload costs $225 on one model and $5.40 on another — a 40× difference — and the cheapest tier handles it for less than a dollar. Rates move constantly (use the live table above for today's numbers), but the shape holds: small-model tiers are effectively free for prototypes, and frontier models are a deliberate purchase. Price your features on the cheap tier first, then upgrade only where quality measurably fails.
Three levers, all stable across the major providers even as list prices move:
| Lever | Typical discount | How it works |
|---|---|---|
| Batch API | 50% off | Submit non-urgent requests in bulk; results arrive in hours instead of seconds. Perfect for backfills, evaluations, document processing. |
| Prompt caching | 50-90% off cached input | Repeated prompt prefixes (system prompts, RAG context) get served from cache — e.g. GPT-5 cached input at $0.125/1M vs $1.25 list. |
| Context-tier pricing | Pay less under a threshold | Some models charge a lower rate below a context cutoff (often ~200K); staying under it compounds with the other two. |
Caching deserves special attention if your app sends the same system prompt on every call — at 80% cache hit rates, an input-bound workload can cut its input bill by three-quarters without touching a single prompt. And the levers stack: a batch job over cached, short-context requests can run at a small fraction of list price.
Match the tier to the job, not the brand:
The classic architecture is a cascade: try the cheap model, check the answer, escalate only on failure. You get frontier quality on the hard minority of requests and commodity pricing on everything else. The token counter helps you size prompts before they ship, and the prompt writing guide covers trimming the tokens you're paying for at both ends.
Provider dashboards all report the same four things, give or take: input tokens, output tokens, cached tokens, and requests. Two habits make bills predictable. First, log your own token counts per feature — when spend jumps, you want to know which feature did it, not just that it happened. Second, watch the input-to-output ratio; a chat app drifting from 3:1 to 10:1 usually means a RAG pipeline started stuffing context, and that's a caching opportunity, not a price hike to eat.
Beware per-request thinking on high-volume features. A model at $1 per million tokens is cheap per call but not free at ten million calls a month — the calculator above exists so you never have to do that multiplication in your head.
It depends entirely on volume. A prototype doing 1M input and 500K output tokens a day runs about $5-$47 a month on flash-class models versus roughly $190-$225 on flagship tiers. Production apps range from tens to thousands of dollars — model choice and volume dominate the bill.
Roughly ¾ of a word. At $1 per million input tokens, a 1,000-word prompt costs about a tenth of a cent. Frontier output tokens at $10-$50 per million cost 1-5 cents per 100 words generated.
Generation is sequential — every output token requires a full forward pass conditioned on the context so far, while input tokens are processed in parallel once. Providers pass that compute difference through: outputs typically run 3-5× the input rate, and up to 10× on some tiers.
Yes — several models in the live table above list at $0 through OpenRouter, and the major clouds each ship a small free tier (Google's AI Studio has a no-cost quota for its flash models, for instance). Free tiers rate-limit aggressively; fine for testing, not for production.
Three levers, in order of payoff: batch your non-urgent jobs (50% off), enable prompt caching for repeated prefixes (50-90% off cached input), and shorten prompts and cap max output tokens. A cascade that escalates only failed requests to a bigger model compounds all three.