AI API pricing is a labyrinth of tiered subscriptions, token-based rates, and “free” tiers that quietly bill you over the limit. Estimate a monthly bill for any non-trivial workload — RAG, an agent looping 200 tool calls, a long-context summarization job — and the same wall shows up: every lab prices differently, the published rate card is rarely the rate you actually pay, and the line items (prompt caching, batch discounts, reasoning tokens, image output, fine-tuned inference) scatter across a dozen pages that change without notice. Here is what AI actually costs in 2026 — across OpenAI, Anthropic, Google, Mistral, DeepSeek, xAI, and self-hosted open-source — and where your spend actually goes.
The numbers below come from each lab’s canonical pricing page as of August 2026: OpenAI, Anthropic, Google AI Studio, DeepSeek, Mistral, and xAI. Where the canonical page does not list a model (newly released, regional SKU, model-garden), we route through Vertex AI Model Garden or Replicate for cross-checking. The aim is not a price list — every lab already publishes one — but a practitioner’s read on which rate matters for which workload, and where the hidden costs hide.
Why API pricing in 2026 is harder to read than ever
Three structural changes have made API pricing genuinely more complex since 2024. First, the unit of billing has multiplied: most frontier labs now charge separately for input tokens, output tokens, cached input tokens (read and write), batched tokens, reasoning tokens, and image output. A single API call can produce four or five line items on your bill. Second, “free” tiers have proliferated — Gemini, Mistral, and several OSS gateways advertise free access, but with rate limits (1-15 RPM, 1-4M TPM) and exclusions (no caching, no batch, smaller models). The free tier is a trial, not a budget plan. Third, every lab now runs multiple model families simultaneously — GPT-5, GPT-5.6, GPT-5.3-codex, o-series reasoning, plus legacy 4o-mini and 4.1-mini on OpenAI; Claude Opus, Sonnet, Haiku, plus 3.x legacy on Anthropic; Gemini 2.5 Pro/Flash/Flash-Lite and preview 3.0 on Google. The rate card is a small spreadsheet, not a single number.
The other structural shift is the rise of consumption discounts that look like pricing but are actually routing. Prompt caching (Anthropic, OpenAI, Google), batch API (50% discount for 24-hour SLA), provisioned throughput (committed-use discounts on Vertex and Bedrock), and volume tiers (DeepSeek’s high-cache-hit pricing) all change the effective rate by 2-10x depending on usage pattern. A workload that pushes 80% of tokens through a warm cache might pay a tenth of the published rate. A workload that streams fresh context every call pays full price. The lab’s headline rate is a floor, not an average.
For practitioners, the practical implication is that the only rate that matters is the rate you actually pay — which means instrumenting by token, by model, by route, and by cache hit rate. OpenAI‘s usage dashboard, Anthropic‘s console, and Google Cloud‘s billing export all give you this at the call level, but only if you tag your requests with a usage-metadata field. The companies that win on cost in 2026 are the ones that instrument from day one, not the ones that pick the cheapest headline rate.
Frontier API rates: OpenAI, Anthropic, Google compared
The closed-source frontier in mid-2026 is three labs at the top — OpenAI, Anthropic, Google — with a fourth (xAI) close behind. All publish token-based rates; all charge input and output at different per-million-token prices; all offer prompt caching at a discount; all offer batch at roughly half price. The table below summarizes the rates that matter for production traffic. Where a lab doesn’t list a model, we note “preview” or “model garden” as the route.
| Model | Input $/M | Output $/M | Cache read | Batch discount |
|---|---|---|---|---|
| OpenAI GPT-5.6 | ~$2.50 | ~$10.00 | ~10% of input | 50% / 24h |
| OpenAI GPT-5 | ~$1.25 | ~$5.00 | ~10% of input | 50% / 24h |
| OpenAI o-series reasoning | ~$3.00-$15 | ~$12-$60 | varies | 50% |
| Anthropic Claude Opus 4.x | ~$15.00 | ~$75.00 | ~10% of input (write +25%) | 50% |
| Anthropic Claude Sonnet 4.x | ~$3.00 | ~$15.00 | ~10% of input | 50% |
| Anthropic Claude Haiku 4.x | ~$0.80 | ~$4.00 | ~10% of input | 50% |
| Google Gemini 2.5 Pro | ~$1.25 (<200K) / $2.50 (>200K) | ~$5.00 / $10.00 | ~10% of input (storage rate) | 50% |
| Google Gemini 2.5 Flash | ~$0.075 | ~$0.30 | ~10% (free up to 1M storage) | 50% |
| Google Gemini 2.5 Flash-Lite | ~$0.02 | ~$0.06 | — | 50% |
Three patterns stand out. First, output is 3-5x more expensive than input on every frontier lab — generating tokens is the dominant cost driver, not consuming them. Second, cache reads are an order of magnitude cheaper than fresh input — any workload with a stable system prompt or retrieved prefix should cache. Third, the floor for production frontier usage (excluding reasoning, image, and tool calls) is roughly $1-$3 per million input tokens and $5-$15 per million output tokens. If you are paying more than this, you are paying for reasoning, image, or a premium tier.
The gap between Sonnet-class and Opus-class on Anthropic is roughly 5x; the gap between Flash and Pro on Google is roughly 17x. Choosing the right tier — not the best model — is where most cost reductions come from. A 2026 frontier deployment that hasn’t benchmarked its workload against two tiers below its current default is overpaying by 2-3x. For a deeper dive into where each model lands on benchmarks, our 2026 frontier model benchmark walks through the quality curve; the short version is that for most non-reasoning tasks, Sonnet 4.x and Gemini 2.5 Pro are within a few points of Opus and Gemini 3 on standard evals, and 5x cheaper.
The cheap seats: DeepSeek, Mistral, xAI, and OSS models
The interesting pricing action in 2026 is not at the frontier — it’s at the tier just below. DeepSeek, Mistral, and xAI all run near-frontier quality at 5-20x lower cost than OpenAI/Anthropic, and the open-weights ecosystem (Llama 4, Qwen 3, DeepSeek-V4) has closed most of the quality gap for non-reasoning workloads. If you are not using these tiers, you are leaving money on the table.
DeepSeek‘s pricing strategy has been aggressive since the V3 release in late 2024 and has continued with V4-Pro and V4-Flash in 2026. Per the DeepSeek pricing page, V4-Pro input is in the $0.10-$0.50/M range with cache hits even cheaper; V4-Flash and V4-Flash-Vision are sub-$0.10/M. Cache hit pricing is the standout: reads cost a fraction of a cent per million tokens, making DeepSeek attractive for high-cache-hit RAG workloads. The trade-off is English-language quality on niche domains (DeepSeek still trails Claude and GPT on long-tail factual recall) and higher latency on cold requests.
Mistral AI runs a tiered commercial stack — Mistral Large (2407, 2411, 2505, 2508), Medium (2505, 2508), Small, and Codestral — alongside Apache-licensed open-weights models (Mixtral, Mistral 7B). The commercial rates are roughly 30-50% of Anthropic Sonnet for comparable quality on European-language and coding tasks. Codestral in particular is a strong value pick for code-completion workloads where frontier reasoning isn’t needed. For OSS self-hosting, Mistral’s open weights are competitive with Llama 3.3 70B on standard benchmarks.
xAI‘s Grok-4.6 and Grok-4.20 are priced at $2.00 input / $6.00 output per million tokens — between Anthropic Sonnet and Haiku on input, and roughly Sonnet-tier on output. xAI also offers image generation at $0.02/image and video generation starting at $0.07/second — useful for multimodal pipelines. For pure text workflows, Grok is competitive on speed (often the lowest latency tier on third-party benchmarks) but trails on long-context and reasoning evals.
The pattern across the cheap seats is the same: you trade some quality, latency, or ecosystem maturity for a 3-20x cost reduction. For most production traffic — bulk summarization, classification, extraction, code completion, simple RAG — the cheap seats are good enough. For reasoning-heavy tasks (multi-step planning, complex math, agentic loops), the frontier still pays for itself. For a deeper comparison of model quality at each tier, our 2026 model rankings and frontier benchmark pieces map the trade-off curve.
Self-hosted and OSS: when the GPU bill beats the API
Self-hosting open-weights models — Llama 4, Qwen 3, DeepSeek-V4, Mixtral — on rented or owned GPUs is now a credible alternative to frontier APIs for high-volume workloads. The breakeven math has shifted dramatically since 2024: a single H100 at ~$2-$3/hour can serve 5-15M output tokens/day of a 70B-class model, which at Anthropic Sonnet rates would cost $75-$225/day. Past ~5M output tokens/day of consistent usage, the GPU bill beats the API.
The numbers depend heavily on quantization. Quantization — reducing model weights from 16-bit (FP16) to 8-bit (INT8) or 4-bit (INT4/GGUF) — cuts VRAM requirements by 2-4x with a small quality hit. A 70B model that needs ~140GB at FP16 fits on a single H100 at INT8 (70GB) and on two A100s at INT4 (~40GB). Quantized inference is now the default for most self-hosted deployments; HuggingFace Inference and Replicate both serve quantized variants by default.
Frameworks matter too. vLLM, Text Generation Inference (TGI), llama.cpp, and TensorRT-LLM each have different throughput profiles. vLLM dominates batch throughput; llama.cpp dominates consumer-GPU (4090, 5090) and CPU-edge deployments; TensorRT-LLM dominates NVIDIA-optimized production. A naive Transformers-based deployment can be 5-10x slower than vLLM at the same hardware, which is the difference between self-hosting winning and losing the breakeven math.
Where self-hosting loses: low-volume workloads (below 1-2M tokens/day), spikey traffic (idle GPU cost during quiet hours), and workloads that genuinely need frontier reasoning. Where self-hosting wins: stable, high-volume text workloads where you control the model, the latency, and the data. For practitioners considering the switch, our local LLM setup guide walks through Ollama, LM Studio, and GPT4All as entry points; our small language models piece covers the 7B-vs-70B trade-off.
Subscriptions, seats, and consumer plans: ChatGPT Plus, Claude Pro, Gemini Advanced
The consumer subscription tier — ChatGPT Plus ($20/mo), Claude Pro ($20/mo), Gemini Advanced ($20/mo), Copilot Pro ($20/mo), Perplexity Pro ($20/mo) — looks commoditized. The differences hide in the caps, the model access, and the features. ChatGPT Plus gives GPT-5 with message caps (roughly 80 messages / 3 hours on GPT-5, unlimited on GPT-5-mini), plus image generation, file analysis, and custom GPTs. Claude Pro gives Claude Sonnet 4.x with similar caps, plus extended thinking mode. Gemini Advanced gives Gemini 2.5 Pro with Deep Research, Veo video, and 2TB Drive storage. Copilot Pro gives GPT-5 access inside Office apps.
The breakeven math vs the API: at $20/mo, you get roughly 80-200 messages of frontier-class usage. If your use is below ~50 messages/day of GPT-5-class work, Plus wins on cost. Above that, the API at ~$2.50/M input + $10/M output tokens — call it $0.05-$0.20 per typical message — is cheaper than Plus once you exceed ~150 messages/day. The hidden cost is the features: image generation, file analysis, memory, and custom GPTs are not on the API at any reasonable price. If you need those, Plus is the floor.
The team and enterprise tiers — ChatGPT Team ($25/mo), Claude Team ($25 or $30/mo), Gemini Business ($20/mo) — add admin controls, SSO, and audit logs at modest markup. The enterprise tiers (custom pricing, typically $60+/seat/mo) add data retention controls, regional residency, and SLAs. For organizations with compliance requirements, the enterprise tier is non-negotiable; for individuals and small teams, the $20 consumer tier plus pay-as-you-go API is usually the right answer.
Per-task cost calculator: what does AI actually cost you
The abstract rate card is less useful than the dollar figure for a real workload. Three concrete scenarios below — each with input/output token counts grounded in typical production usage — show what AI actually costs on the major labs as of mid-2026.
Scenario 1: 1M-token document summarization. A 1M-token input (roughly a 750-page book or a long compliance document), 2K-token output summary. At GPT-5.6 rates (~$2.50/$10.00 per M input/output): $2.50 input + $0.02 output = $2.52 per document. At Claude Opus 4.x (~$15/$75): $15.00 + $0.15 = $15.15. At Gemini 2.5 Pro (~$1.25/$5.00 under 200K, but 1M is over 200K so $2.50/$10.00): $2.50 + $0.02 = $2.52. At DeepSeek-V4-Pro (~$0.50/$2.00): $0.50 + $0.004 = $0.50. The same job, 5-30x cost difference, depending on the lab. With caching (the document becomes a cached prefix for re-summarization), the cost on subsequent runs drops to ~$0.005-$0.05 per query.
Scenario 2: 100K-token code review. A repository’s worth of code (~100K tokens), 5K-token review comment. At GPT-5: ~$0.13 input + $0.025 output = $0.16 per review. At Claude Sonnet 4.x: ~$0.30 input + $0.075 output = $0.38. At DeepSeek-V4-Flash: ~$0.01 + $0.001 = $0.01. At local Qwen 3 Coder 32B on a rented A100 (~$1.50/hour, ~30 reviews/hour): $0.05. For a CI pipeline that runs 50 reviews/day, that’s $8/day on GPT-5 vs $0.50/day on DeepSeek-Flash vs $2.50/day on local. The Frontier Quality Differential Is Real But The Cost Differential Is Larger — pick the tier that meets your quality bar, not the tier that’s marketed as “frontier.”
Scenario 3: Agent workflow with 20 tool calls. A coding agent that loops through 20 LLM calls per task, each averaging 5K input + 1K output tokens (typical ReAct-style agent). At GPT-5: 20 × (5K × $1.25/M + 1K × $5.00/M) = 20 × ($0.00625 + $0.005) = $0.225 per agent task. At Claude Sonnet: 20 × ($0.015 + $0.015) = $0.60 per task. At DeepSeek-V4-Flash: 20 × ($0.0005 + $0.0005) = $0.02 per task. For an agent platform running 1,000 tasks/day: $225/day on GPT-5, $600/day on Claude Sonnet, $20/day on DeepSeek. The decision matrix is straightforward: if your agent has high failure rate and needs frontier reasoning, pay for the frontier; if your agent is well-prompted and the cheap seats work, the savings compound.
For more on agent economics, our production agents guide covers the cost modeling in depth, and our 2026 agent landscape piece maps which labs are cheapest for which agent patterns. Our earlier AI inference cost piece is also worth revisiting — it focused on single-prompt economics; this piece extends to multi-call workflows.
Where to spend in 2026 (and where to skip)
The decision matrix for AI spend in 2026 is simpler than the rate cards make it look. Heavy batch / bulk summarization / extraction: DeepSeek-V4-Flash or quantized OSS on rented GPUs. The cost-per-token is 10-30x lower than frontier and the quality bar for extraction is reachable. Coding workflows: Claude Sonnet 4.x for code review and architecture discussions; local Qwen 3 Coder or Codestral for completion and inline suggestions. Image generation: FLUX via Replicate or dedicated Stable Diffusion deployments; the API route via OpenAI or Google is 5-10x more expensive per image. Long-context RAG: Gemini 2.5 Flash for the long-context sweet spot; for 1M+ contexts with frequent queries, caching makes Gemini Flash cheaper than splitting into smaller chunks. Reasoning tasks: OpenAI o-series or Claude Opus 4.x; the cheap seats still trail on multi-step reasoning by 5-15 points on standard evals.
The bigger lever, though, is instrumentation. Track tokens by model, by route, by cache hit rate, by user. Most teams that adopt this discipline find 30-50% of their spend is on routes that could be 5-10x cheaper with a different model or a cached prefix. The frontier labs are not subsidizing your workload — they are pricing per the unit economics of inference. Your job is to pick the lab whose unit economics match your workload shape, not to pick the “best” lab. For context on where each lab is investing — and what that means for pricing trajectory — our AI funding analysis maps the capex cycle and our AI jobs piece covers the labor market side.
Frequently asked questions
What’s the cheapest frontier AI API in 2026?
DeepSeek-V4-Pro leads on raw $/Mtoken, with input rates roughly 15-20x cheaper than GPT-5.6. For most non-reasoning workloads, it produces near-frontier quality at a fraction of the cost. Among closed models, Gemini 2.5 Flash-Lite is the cheapest Google option at sub-$0.10/M input.
Is the $20/month ChatGPT Plus worth it vs the API?
If you’re under ~50 messages/day of GPT-5-class usage, Plus wins on cost. Above that, the API is cheaper per-message but loses Plus’s image gen, file analysis, and memory features. Heavy automation always goes to the API.
When does self-hosting beat paying for an API?
Roughly above ~5M output tokens/day of consistent usage, a single H100 rental beats frontier API rates. Below that, the dev/ops overhead and idle capacity make API cheaper. Quantized 70B models on consumer GPUs (4090, 5090) are now viable for sub-100 tok/s workloads.
Are free tiers actually free?
No. Gemini and Mistral free tiers are rate-limited (typically 1-15 RPM and 1-4M TPM) and exclude context caching, batch, and certain models. OpenAI stopped offering free API access in 2023; only ChatGPT consumer free exists, and it routes to older/smaller models.
What’s the hidden cost of long context windows?
Long-context pricing scales with tokens, not “pages.” A 500K-token Gemini request costs 50x a 10K-token request. Most providers charge cache reads at 10% of input cost, but cache writes still cost full price. For RAG, smaller chunks with reranking beat stuffing 1M context windows — our context window piece covers the retrieval quality trade-off.
Conclusion
AI API pricing in 2026 is not a single number — it is a portfolio decision. The frontier labs charge premium rates for reasoning, agentic, and image workloads where they lead on quality. The cheap seats — DeepSeek, Mistral, xAI, OSS — handle the bulk of non-reasoning traffic at 5-20x lower cost. Self-hosted quantized models on rented or owned GPUs beat the API above ~5M output tokens/day of consistent volume. The consumer $20/mo subscriptions make sense for sub-50 messages/day of frontier-class work and lose to the API above that threshold. The action items: audit your last 30 days of API spend by model and route, move bulk and batch workloads to DeepSeek or quantized OSS, use caching aggressively for repeated prefixes, and track tokens — not requests. The frontier quality differential is real, but the cost differential is larger. Spend accordingly.