TL;DR (May 2026): The flagship ladder runs from GPT-5.5 ($5/$30 per 1M input/output) and Claude Opus 4.7 ($5/$25) down through Gemini 3.1 Pro ($2/$12) to the value tier, Kimi K2.6 ($0.60/$2.50) and DeepSeek V4 Flash ($0.14/$0.28). Your monthly bill is (input tokens × input price) + (output tokens × output price), minus an 80-90% cut on whatever you cache. Cheapest flagship: Gemini. Cheapest production-grade model overall: DeepSeek V4 Flash. The model you should actually pick depends on workload shape, the table and worked examples below do the math.
"Which LLM API is cheapest?" is the wrong question, but it's the one everyone types into search. The right question is "what will my workload cost on each model, after caching, retries and real call volume?" This article is the dated pricing comparison and worked examples. For your own assumptions, use the free LLM cost-per-task calculator, which deliberately asks you for the current rates instead of pretending a hard-coded price table stays current.
All prices below are current as of May 2026 and reused from our two deep-dive pricing articles (flagship ladder and value tier). Pricing has moved roughly every six weeks across these providers in 2026, so check the source pages before you commit a budget.
The big comparison table, every major API model
| Model | Input ($/1M) | Output ($/1M) | Cached input ($/1M) | Context window |
|---|---|---|---|---|
| GPT-5.5 | $5.00 | $30.00 | $0.50 | 270K |
| GPT-5.2 | $1.75 | $14.00 | $0.18 | 200K |
| Claude Opus 4.7 | $5.00 | $25.00 | $0.50 | 200K |
| Claude Sonnet 4.6 | $3.00 | $15.00 | $0.30 | 200K |
| Claude Haiku 4.5 | $1.00 | $5.00 | $0.10 | 200K |
| Gemini 3.1 Pro (≤200K ctx) | $2.00 | $12.00 | $0.20 | 2M |
| Gemini 3.1 Pro (>200K ctx) | $4.00 | $18.00 | $0.40 | 2M |
| Kimi K2.6 (Moonshot) | $0.60 | $2.50 | , | 256K |
| DeepSeek V4 Flash | $0.14 | $0.28 | $0.0028 | 128K |
| DeepSeek V4 Pro (75% off thru 2026-05-31) | $0.435 (list $1.74) | $0.87 (list $3.48) | $0.0036 | 128K |
The spread is staggering: GPT-5.5 output costs 107x DeepSeek V4 Flash output and 12x Kimi K2.6. Three structural facts to keep in mind before you read any verdict:
- Output is the expensive half. Every model here charges 2x-6x more for output than input. Workloads that read a lot and write a little (RAG, classification, extraction) are cheap. Workloads that generate long text or code are where the bill lives.
- Caching is the biggest lever you control. Cached input runs 80-90% below standard input across Claude, GPT, and Gemini, and roughly 50x cheaper on DeepSeek. Any prompt prefix repeated across requests in a short window should be cached.
- Token counts are not portable. Each provider tokenizes differently, Opus 4.7's tokenizer alone produces up to 35% more tokens per character than 4.6. Compare dollars-per-outcome on your own eval suite, not headline rates.
How to calculate your monthly bill
The formula is simple; the discipline is in measuring your real token shape instead of guessing it.
Monthly cost =
(uncached_input_tokens / 1,000,000 × input_price)
+ (cached_input_tokens / 1,000,000 × cached_price)
+ (output_tokens / 1,000,000 × output_price)
Multiply each per-request figure by your monthly request count. The trap is the cached vs uncached split: most teams assume zero caching, get a scary number, panic, and route everything to the cheapest model. In reality a stable system prompt or RAG corpus moves a big chunk of input into the 10%-of-list cached tier.
Worked example
Say you run a chat feature: 500,000 requests/month, each with 3,000 input tokens (a 2,000-token system prompt that never changes, plus 1,000 tokens of fresh user/context) and 600 output tokens. On Claude Opus 4.7:
- Uncached input: 500K × 1,000 = 500M tokens × $5 = $2,500
- Cached input (the 2K system prompt): 500K × 2,000 = 1,000M tokens × $0.50 = $500
- Output: 500K × 600 = 300M tokens × $25 = $7,500
- Total: $10,500/month
Without caching that same workload is $13,500, the cache saves $3,000/month for one line of API config. Run the identical shape on Gemini 3.1 Pro and you get $1,000 (uncached input) + $200 (cached) + $3,600 (output) = $4,800/month, less than half. On DeepSeek V4 Flash it collapses to about $224/month. The model choice swings this single feature by 47x.
Three workload scenarios, costed across the field
Headline rates don't tell you what you'll pay because no real workload matches the headline shape. Here are three patterns we see constantly, with the math worked out.
Scenario A: support agent (small in, small out, high volume)
2,000 input tokens (half is a fixed system prompt → cacheable), 500 output tokens, 50,000 requests/month.
| Model | Monthly (no caching) | Monthly (with caching) |
|---|---|---|
| GPT-5.5 | $1,250 | $762 |
| Claude Opus 4.7 | $1,125 | $687 |
| Claude Haiku 4.5 | $225 | $163 |
| Gemini 3.1 Pro | $500 | $350 |
| Kimi K2.6 | $123 | $123 |
| DeepSeek V4 Flash | $21 | $18 |
A support agent rarely needs flagship reasoning. Haiku 4.5, Kimi, or DeepSeek Flash do the job at a fraction of the cost. Reach for Opus or GPT-5.5 here only if your escalation-detection quality genuinely improves enough to justify a 5x-50x bill.
Scenario B: RAG app (large input, small output, medium volume)
20,000 input tokens (8,000 of stable retrieved context cacheable within a session), 800 output tokens, 100,000 requests/month.
| Model | Monthly (with caching) |
|---|---|
| GPT-5.5 | $8,400 |
| Claude Opus 4.7 | $7,400 |
| Gemini 3.1 Pro | $3,320 |
| Claude Sonnet 4.6 | $4,440 |
| DeepSeek V4 Flash | $190 |
RAG is input-dominated, so the cheap-input models win big and caching the retrieved context matters more than anything else. Gemini's flat $2 input and 2M window make it the strong flagship pick here; DeepSeek Flash is the volume play when occasional misses are cheap to catch.
Scenario C: agent loop with tool calls (many turns, history re-sent)
10 turns per task, each 5,000 input / 1,000 output; later turns re-send history so caching helps massively; 5,000 tasks/month.
| Model | No caching | With caching |
|---|---|---|
| GPT-5.5 | $3,750 | $1,125 |
| Claude Opus 4.7 | $3,500 | $1,050 |
| Gemini 3.1 Pro | $1,400 | $420 |
| Kimi K2.6 | $275 | $275 |
| DeepSeek V4 Flash | $84 | ~$40 |
Agent loops re-send the conversation every turn, so caching is the difference between a sustainable and a runaway bill, it cuts the flagship loop cost by ~70%. If you're running a Claude or GPT agent loop without prompt caching, your bill is roughly 3x what it should be.
Cheapest by use case, the verdict
- High-volume support / classification: DeepSeek V4 Flash, then Claude Haiku 4.5 if you want a Western-hosted option with stronger safety tuning.
- RAG over a stable corpus: Gemini 3.1 Pro for quality-sensitive work (cheap input + 2M window), DeepSeek V4 Flash for cost-sensitive bulk.
- Autonomous coding agents: Kimi K2.6 or Claude Sonnet 4.6, close to Opus on SWE-Bench at a fraction of the price.
- Final code review / hard reasoning: Claude Opus 4.7, used selectively. This is the workload that justifies $25/M output.
- Tool-heavy branching agents: GPT-5.5 still leads on function-calling reliability.
- Very long context (>250K tokens): Gemini 3.1 Pro is the only flagship with the window.
- Cheapest flagship overall: Gemini 3.1 Pro, 60% under Opus on input, 52% under on output.
The single most common cost mistake in the usage data we see: teams routing everything to a flagship "to be safe," then complaining about the bill. The second most common: never turning on caching. Both are fixable in an afternoon.
Track your REAL per-customer, per-model cost
A calculator built on assumed token counts is a starting estimate, not a budget. The number that actually matters is your measured cost per customer and per model, because that's what tells you whether a noisy customer is eating your margin, or whether last week's price change moved your unit economics.
Use the free cost-per-task calculator when you want to compare workload assumptions without maintaining another hard-coded provider price table. In production, UsageBox can retain the numeric token quantity or cost value your application already computes and route it through the customer subscription plus explicit meter/product-item keys. Model identity and richer workload metadata remain in your application analytics unless you intentionally separate them into different UsageBox meter streams.
Bottom line
Plug your real token shape into the formula above, run it against the table, and you'll usually find that (a) caching saves more than switching providers, and (b) the cheapest model that passes your quality bar is several tiers below the flagship you reflexively reached for. Estimate with the calculator, then confirm with measured per-customer data before you lock in a vendor.
Related reading
- GPT-5.5 vs Gemini 3.1 Pro vs Claude Opus 4.7 Pricing, the flagship cost ladder in depth
- Claude Sonnet vs Kimi vs DeepSeek: Real Pricing, the value-tier breakdown and benchmarks
- Prompt Caching Cost Optimization, how to wire caching across all three flagship providers
- Gemini API Free Tier (2026), the free-tier-after-billing gotcha for Gemini calls
- Claude API Billing in 2026, per-model limits and caching math for Opus/Sonnet/Haiku