One million output tokens costs $0.15 on DeepSeek-V3, $30 on GPT-5.5, and $45 on o1-Pro. That is a 300x price spread —between models that, for a large share of production workloads, produce indistinguishable results. If you picked the wrong model and never looked back, your API bill is telling the story right now.
The gap is real and growing. Over the past eighteen months, frontier model prices have climbed as reasoning capabilities expanded, while a parallel wave of high-efficiency models —DeepSeek, Gemini Flash, Llama 4 —has driven the floor down to near-zero. The result is a market where two teams running similar workloads can pay $300/month or $9,000/month, and the cheaper one is often delivering the better user experience because it responds faster.
Closing that gap does not require an infrastructure overhaul. One team routes “hello” and “thanks” through a lightweight classifier instead of a reasoning model and cuts $7,500 from a $9,700 monthly bill —a 78% drop —while latency improves. Another enables prompt caching on repetitive system prompts and saves 50% on input token costs with no code changes. Aggregate data across production deployments shows that systematic model-tier routing plus caching typically recovers 60-80% of LLM API spend.
Here’s what you’ll walk away with: a four-tier pricing table covering every model that matters in July 2026, a quality-per-dollar ranking that tells you which model actually delivers for what you pay, three reader-profile recommendations (not generic budget tiers), and a decision framework that answers “which model for what” in one sentence.
The Complete 2026 LLM API Pricing Table
There are over 180 models available through major APIs as of mid-2026. Most of them you’ll never use. What matters is understanding the pricing structure —not memorizing every number. Models cluster into four tiers based on capability and cost. Here’s what you need to know about each.
Tier 1: Frontier Models ($2–30 per million tokens)
These are the flagships. You run them when the task demands maximum reasoning depth: complex debugging sessions, multi-step agent workflows, legal document analysis where a hallucination costs more than the API call.
| Model | Provider | Input ($/1M tok) | Output ($/1M tok) | Context Window | SWE-bench Verified |
|---|---|---|---|---|---|
| GPT-5.5 | OpenAI | $5.00 | $30.00 | 1M | 88.7% |
| GPT-5.5 Pro | OpenAI | $30.00 | $180.00 | — | — |
| Claude Opus 4.8 | Anthropic | $5.00 | $25.00 | 1M | 88.6% |
| Claude Sonnet 4.6 | Anthropic | $3.00 | $15.00 | 1M | ~85% |
| Gemini 3.1 Pro | $2.00 ($4 >200K) | $12.00 ($18 >200K) | 1M (2M preview) | 80.6% |
GPT-5.5 and Claude Opus 4.8 are statistically tied at the top of the SWE-bench Verified leaderboard. In practice, the deciding factor isn’t capability —it’s ecosystem. GPT-5.5 has the largest plugin and SDK ecosystem. Claude Opus has the strongest native tool-use protocol and extended thinking. Gemini 3.1 Pro is the value play in this tier: 2.5x cheaper than GPT-5.5 on output, with the best free tier (1,500 requests/day via Google AI Studio) and the only model with native multimodal support —video, audio, and images processed in a single API call.
The GPT-5.5 Pro tier at $30/$180 per million tokens exists for workloads where maximum reasoning depth is non-negotiable: drug discovery simulations, formal verification of safety-critical systems, frontier research. For 99.7% of use cases, the base GPT-5.5 is the right choice.
Tier 2: Value Frontier ($0.50–2 per million tokens)
This is where the 2026 price-performance revolution happened. Models in this tier score 80%+ on SWE-bench Verified —competitive with frontier models from 18 months ago —at 5–20x lower cost.
| Model | Provider | Input ($/1M tok) | Output ($/1M tok) | Context | SWE-bench |
|---|---|---|---|---|---|
| DeepSeek V4 Pro | DeepSeek | $0.435 | $0.87 | 1M | ~85% |
| Qwen3.7 Max | Alibaba | $1.25 | $3.75 | 1M | 80.4% |
| MiniMax M3 | MiniMax | $0.60 | $2.40 | 1M | 80.5% |
| Kimi K2.6 | Moonshot | $0.95 | $4.00 | 256K | 80.2% |
| GLM-5.2 | Z.AI | $1.40 | $4.40 | 1M | — |
| Mistral Large 3 | Mistral | $0.50 | $1.50 | 262K | — |
The standout in this tier is MiniMax M3: at $0.03 per SWE-bench point —the best coding capability per dollar of any model on the market. DeepSeek V4 Pro is the overall value leader: 1/34th the output cost of GPT-5.5 while delivering coding quality that’s indistinguishable from frontier models for ~85% of real-world tasks.
Mistral Large 3 deserves a special mention for EU-based teams: GDPR-compliant, EU-hosted, free tier available, and the only model in this tier with a clear data-residency story.
Tier 3: Budget Workhorses ($0.10–0.50 per million tokens)
For high-volume, cost-sensitive workloads where absolute frontier capability isn’t required:
| Model | Provider | Input ($/1M tok) | Output ($/1M tok) | Context | Best For |
|---|---|---|---|---|---|
| DeepSeek V4 Flash | DeepSeek | $0.14 | $0.28 | 1M | Text gen, classification, simple coding |
| GPT-5.4 Nano | OpenAI | $0.20 | $1.25 | 128K | OpenAI ecosystem, moderate quality needs |
| GPT-4.1 Nano | OpenAI | $0.10 | $0.40 | 1M | Long-context, lowest OpenAI pricing |
| Gemini 3.1 Flash | $0.50 | $3.00 | 1M | Multimodal volume workloads | |
| Qwen3-32B | Alibaba | $0.18 | $0.28 | 32K | Multilingual (Arabic, Japanese, Korean) |
| Llama 4 Scout | Meta (hosted) | $0.11 | $0.34 | 10M | Longest context window in this tier |
DeepSeek V4 Flash at $0.14/$0.28 is the anchor of this tier. It scores 92% on HumanEval (coding) —0.5 points below GPT-4o —at 1/40th the output price. For text classification, summarization, simple Q&A, and boilerplate code generation, there is no reason to use anything more expensive.
Tier 4: Free Tier Models (Permanent)
These aren’t trials. They’re permanently free —with rate limits and caveats you need to understand before building on them.
| Model | Provider | Rate Limit | Context | Caveat |
|---|---|---|---|---|
| GLM-4.7 Flash | Z.AI | ~1,000 req/day | 128K | Completely free, Chinese-first docs |
| Gemini 2.5 Flash | 1,500 req/day | 1M | May use data for training (free tier) | |
| Groq free models | Groq | 30 RPM / 14,400 RPD | Various | Fastest inference (300–500 tok/s) |
| Cerebras free | Cerebras | 30 RPM / 1M tok/day | Various | Fastest batch throughput (2,500+ tok/s) |
| OpenRouter free | OpenRouter | 20 RPM / 200 RPD | Various | 35+ free models, single key |
Free tiers are for prototyping and personal tools. The moment you need reliability, an SLA, or data privacy guarantees, switch to a paid tier —or better, an aggregation platform that lets you scale from free prototyping to paid production without changing your API endpoint.
For a complete breakdown of free-tier capabilities, including what you can actually build with $0, see our Cheapest LLM API Providers guide (Article #3 in this series).
The 300x Price Spread
The cheapest model in this table is $0.10 per million input tokens (GPT-4.1 Nano). The most expensive is $30 per million (GPT-5.5 Pro) —a 300x spread on input alone. On output, the gap is even wider: from $0.01/M (Qwen3-8B, GLM-4-9B at the absolute floor) to $180/M (GPT-5.5 Pro) —up to an 18,000x difference between the cheapest and most expensive output token.
What drives this gap? Three things: model capability (reasoning depth, coding accuracy, multimodal support), inference cost (larger models need more GPU hours), and market position (OpenAI and Anthropic command premium pricing because of their ecosystem moat —every tutorial, SDK, and tool supports them first).
The practical question isn’t “which model is cheapest.” It’s “which model is good enough for my task, and how much am I overpaying for capability I don’t need?”
Prompt caching changes the effective price dramatically. Anthropic offers 90% off cached input, DeepSeek’s cache hits cost just $0.0036/M, and at 80% cache coverage your effective input cost drops ~72%. For the full cross-provider caching strategy and implementation guide, see our caching implementation guide.
Who Should Use Which Model? By Reader Profile
Generic “$50/$500/$5,000 budget tiers” aren’t useful without context. Here’s who you are and what you should use.
The Solo Developer
You’re building a side project, a prototype, or a small SaaS. Your constraints: budget ($20–50/month for APIs), time (you’re the only developer), and friction (you don’t want to create five provider accounts). You need: one cheap model that handles 90% of your tasks + one premium fallback for the other 10%.
Stack: DeepSeek V4 Flash as your daily driver ($0.14/$0.28). For the ~10% of requests that need more depth, route to Claude Sonnet 4.6 ($3/$15) or GPT-5.4 Mini ($0.75/$4.50). Expected cost: $25–50/month at ~2 million output tokens. All accessible through a single aggregation endpoint —no separate provider accounts required.
Growth path: When your side project hits 10,000 requests/day, you’ve outgrown free tiers but don’t yet need enterprise infrastructure. An aggregation platform lets you keep the same code, same endpoint, and just increase your prepaid balance. No migration. The full multi-model routing guide for the full routing setup.
The Startup CTO
You’re running a team of 3–8 developers. Your production app makes 50,000–200,000 API calls per month. Your constraints: reliability (downtime costs users), cost predictability (runaway bills kill runway), and developer velocity (your team shouldn’t spend time managing provider accounts).
Stack: DeepSeek V4 Pro as your primary coding model ($0.44/$0.87) —it handles 70% of your requests at near-frontier quality. Claude Sonnet 4.6 for complex debugging and PR review ($3/$15). GPT-5.4 Mini for agent workflows ($0.75/$4.50). Gemini 3 Flash for multimodal tasks ($0.50/$3). Expected cost: $400–1,200/month.
Two architectural decisions that matter more than model choice: (1) Implement model fallback —your app should never return “model unavailable” to a user because one provider is down. A two-line try/except that switches from Claude to GPT-5.5 on 429 or 5xx errors is the difference between “incident” and “nobody noticed.” (2) Set cost-per-request ceilings. Not monthly budgets —per-request limits. A runaway agent loop can burn $50 in tokens before a monthly alert fires.
Aggregation platforms handle fallback and cost routing at the infrastructure level. If your team is spending more than 2 hours/month managing provider dashboards, you’re paying a hidden tax that direct API pricing doesn’t show. For the cost comparison math, read why developers are switching to aggregation platforms.
The Enterprise Architect
You’re evaluating LLM infrastructure for a team of 50+ developers or a customer-facing product at scale. Your constraints: compliance (SOC 2, HIPAA, EU AI Act, data residency), governance (who used which model, when, at what cost), and vendor management (you can’t renegotiate contracts with five providers every quarter).
Stack: Your model mix depends on workload —but your infrastructure matters more than your model selection. At enterprise scale, three things determine total cost: prompt caching hit rate (target >60% to cut input costs by half), batch API utilization (every non-real-time workload should use batch at 50% discount), and multi-model routing efficiency (the difference between “all requests to GPT-5.5” and “smart routing” is typically 60–80% cost reduction).
Self-hosting a gateway like LiteLLM gives you full control over data residency, key management, and audit logging —but requires DevOps investment. Managed aggregation platforms provide the same governance layer (virtual keys with per-team budgets and model allowlists, unified audit trails, data residency options) without the infrastructure overhead.
For the security baseline every enterprise LLM deployment needs, start with the guide to API key management. Then layer on compliance requirements specific to your industry. But security and compliance are only half the enterprise cost equation —the other half is what happens when your team needs to change course.
The hidden cost nobody tracks: migration. Every time you switch models, you re-benchmark your prompts. A team of five engineers spending two days per migration at $500/day burns $5,000 per model switch. The teams running three models behind a routing layer switch models in production by changing a configuration value —then measure the results on live traffic at 5% rollout. Same outcome. Zero migration cost. The pricing table above shows per-token costs. What it doesn’t show is that the real cost difference between a single-model and multi-model setup is not the token price —it’s the organizational friction of change. When model prices shift every quarter and new contenders emerge every month, the ability to change models without engineering overhead is worth more than any per-token discount.
Quality per Dollar: The Only Value Ranking That Matters (as of July 2026)
Benchmark scores without pricing are marketing. Pricing without benchmark scores is shopping blind —independent platforms like Artificial Analysis track both across all major providers. The metric that matters is quality delivered per dollar spent.
SWE-bench Verified per Dollar (Coding Value)
This ranking divides each model’s SWE-bench Verified score by its output price per million tokens. Higher is better —it means more coding capability per dollar.
| Model | SWE-bench | Output $/M | Score per Dollar |
|---|---|---|---|
| DeepSeek V4 Flash | ~78% | $0.28 | 279 |
| DeepSeek V4 Pro | ~85% | $0.87 | 98 |
| MiniMax M3 | 80.5% | $2.40 | 34 |
| Qwen3.7 Max | 80.4% | $3.75 | 21 |
| Kimi K2.6 | 80.2% | $4.00 | 20 |
| Gemini 3.1 Pro | 80.6% | $12.00 | 7 |
| Claude Opus 4.8 | 88.6% | $25.00 | 3.5 |
| GPT-5.5 | 88.7% | $30.00 | 3.0 |
Formula: SWE-bench percentage ÷ output dollars per million tokens. Higher = more coding capability per dollar.
DeepSeek V4 Flash delivers 279 coding-score points per dollar —93x the value of GPT-5.5 (3.0). Even DeepSeek V4 Pro, a near-frontier model, provides 28x the coding value per dollar. The “budget” label undersells what’s happening: these models deliver frontier-competitive coding at prices that make all-frontier stacks look wasteful in retrospect.
The interpretation that matters: If you’re spending $1,000/month on GPT-5.5 for coding tasks, switching to DeepSeek V4 Flash would give you similar-quality output for roughly $11/month. Switching to DeepSeek V4 Pro: roughly $30/month. The gap between “what you’re paying” and “what you could be paying” is wider than most teams realize.
This metric exposes something the raw pricing table doesn’t. GPT-5.5 scores 88.7% on SWE-bench —the highest in this comparison. But it costs 93x more per benchmark point than DeepSeek V4 Flash. For a team spending $5,000/month on coding APIs, that 93x multiplier is the difference between a $5,000 bill and a $54 bill for equivalent benchmark performance. The quality gap —3 percentage points on SWE-bench —translates to roughly one additional correct solution per 33 coding tasks. Whether that’s worth $4,946 per month is a business decision, not a technical one. Most teams, once they run the numbers, discover they need frontier models for about 5% of their actual workload.
MMLU-Pro Score per Dollar (General Reasoning Value)
| Model | MMLU-Pro | Output $/M | Score per Dollar |
|---|---|---|---|
| DeepSeek V4 Flash | 85.5 | $0.28 | 305 |
| DeepSeek V4 Pro | ~87 | $0.87 | 100 |
| Qwen3.7 Max | ~86 | $3.75 | 23 |
| Claude Opus 4.8 | ~89 | $25.00 | 3.6 |
| GPT-5.5 | ~89 | $30.00 | 3.0 |
For general knowledge and reasoning tasks, the value gap is even wider than coding. DeepSeek V4 Flash scores within 3.5 points of GPT-5.5 on MMLU-Pro —at 1/100th the price per reasoning point.
The Value Sweet Spot
If you plot every model on a scatter chart —SWE-bench score on the X-axis, output price on the Y-axis —you see three clusters:
- The Premium Corner (top-right): GPT-5.5 and Claude Opus 4.8. Highest scores, highest prices. Best for: tasks where a wrong answer costs more than the API call.
- The Value Sweet Spot (upper-middle, far left): DeepSeek V4 Pro, MiniMax M3, Qwen3.7 Max. 80%+ SWE-bench at $0.87–3.75. Best for: 90% of production workloads.
- The Budget Zone (middle, far left): DeepSeek V4 Flash, GPT-4.1 Nano, Qwen3-32B. Good-enough quality at near-zero cost. Best for: classification, extraction, summarization, boilerplate generation.
The models that don’t make sense on this chart: anything below 75% SWE-bench at >$5/M output. You’re paying frontier prices for non-frontier quality. Check your model version —you might be running a deprecated model that was replaced by a cheaper, better version six months ago.
How aggregation platforms shift the value equation. Aggregated demand across a large user base unlocks per-token pricing below what any single team can negotiate directly —the same economic principle that makes the Quality per Dollar table in this article actionable. Add cost-based routing that sends each request to the cheapest model capable of handling it, and a blended stack (DeepSeek V4 Flash for 70% of traffic + Claude Sonnet for 20% + GPT-5.5 for 10%) operates 30–50% below an all-frontier baseline. End users perceive no quality difference because each request still lands on a model matched to its complexity.
Quick Decision Framework
If you need code generation —DeepSeek V4 Pro (best value), Claude Opus 4.8 (best quality). Fallback: GPT-5.5.
If you need long-document analysis (>100K tokens) —Gemini 3.1 Pro (2M context, cheapest per-token for long docs). Fallback: GPT-4.1 Nano (1M context, $0.10/M input).
If you need multilingual (non-English) —Qwen3.7 Max or DeepSeek V4 Pro (both outperform GPT-5.5 on C-Eval, Japanese, Korean, Arabic benchmarks). Fallback: Claude Opus 4.8.
If you need vision/multimodal —Gemini 3.1 Pro (native video + audio + image). Fallback: GPT-5.5.
If you need agentic workflows (tool calling) —GPT-5.5 (most reliable function calling, best parallel tool execution). Fallback: Claude Opus 4.8 (best complex multi-step reasoning).
If you need the absolute lowest cost —DeepSeek V4 Flash ($0.14/$0.28). Free: GLM-4.7 Flash (permanent free tier, 128K context).
If direct access is limited where you are —Use an aggregation platform that provides access to all models through one endpoint. No per-provider payment barriers. One API key.
FAQ
Which model is the cheapest overall in 2026?
DeepSeek V4 Flash at $0.14 input / $0.28 output per million tokens. For permanently free access: GLM-4.7 Flash (no credit card, 128K context, OpenAI-compatible).
Is Claude Opus worth 5x the price of DeepSeek V4 Pro?
Only if you need Anthropic-native protocol features (extended thinking, computer use) or the last ~3 percentage points of SWE-bench capability for complex debugging. For 95% of coding tasks, DeepSeek V4 Pro delivers indistinguishable quality at 1/29th the output cost. Detailed side-by-side: see our OpenAI vs Anthropic vs Google vs DeepSeek comparison.
Do aggregation platforms actually save money vs. direct API?
Apply the cost-per-benchmark-point logic from the Quality per Dollar section to your monthly invoice and the answer becomes clear. Three mechanisms compound: (1) aggregated purchasing power pushes per-token rates below what individual accounts qualify for, (2) you stop parking $50–200 in minimum deposits that sit idle across provider dashboards, and (3) cost-based routing applies the same tier logic this article maps out —simple queries to $0.14/M models, complex reasoning to $3/M models, frontier-depth work only to $30/M models. Teams running three or more models typically see 30–50% less on their total LLM spend versus maintaining separate direct accounts without that routing layer.
How often do these prices change?
Chinese providers (DeepSeek, Qwen, MiniMax, Kimi, GLM) cut prices six times in the first half of 2026 alone. US providers (OpenAI, Anthropic) adjust quarterly. Google adjusts every 2–3 months. If you’re using pricing data older than 60 days, you’re likely overpaying.
What about batch API pricing?
OpenAI, Anthropic, and Google offer ~50% discount for async batch processing (24-hour turnaround). DeepSeek batch pricing is the same as real-time —no discount, but also no delay penalty. For cost optimization strategies with before/after data, the bill-cutting tactics guide covers this in detail.
Can I use free tier APIs in production?
No. Free tiers cap at 15–30 requests per minute, carry no SLA, and some (Google’s free tier) may use your data for training. Use them for prototyping and personal projects. When you’re ready for production, an aggregation platform lets you switch from free prototyping to paid production without changing your API endpoint.
Pricing tables are only useful if you act on them. Switching from the default stack most teams use —all requests to GPT-5.5 —to an optimized multi-model stack with smart routing typically yields an 80% cost reduction with zero quality loss. The numbers are in this article.
Here’s what to do next: pick one model from Tier 2 or Tier 3 in the table above. Route 20% of your traffic to it this week. Measure the quality. If it’s good enough —and for 85% of workloads, it will be —you just cut your bill by 80%. That’s not an aspirational number. It’s the math in the “Quality per Dollar” section.
The teams that treat pricing as a periodic check —“we’ll look at model prices next quarter” —are the ones that discover they’ve been overpaying by 80% for six months. Pricing moves too fast for quarterly reviews. Set a calendar reminder for the first of every month. Check the pricing table. Adjust your routing rules. Five minutes. That’s the difference between a $1,000 bill and a $200 bill —not better models, not smarter engineers, just a recurring calendar event.
The pricing data in the tables above was verified against provider dashboards and API responses in July 2026. Confirm the numbers against your own prompts —same model, same parameters, compare the per-token cost —using TokSpan’s playground, which reports pricing across models side by side without requiring provider accounts. A $5 prepaid balance is enough to benchmark every model in Tier 2 and Tier 3.