Choosing the right LLM API isn't about finding the most capable model - it's about matching capability to task at a sustainable cost. The 2026 landscape looks nothing like 2024: GPT-4 and Claude 3 are deprecated, 1M-token context is the frontier standard, reasoning is built into the flagships, and a Chinese open-weight model (DeepSeek) undercuts everyone on price.
Last updated: June 2026. All pricing below is USD per 1M tokens (input / output), standard non-batch, non-cached tier, verified as of 2026-06-25. Prices marked with a tilde (~) are best-effort where vendor tables disagree across sources.
Try our free Self-Hosted LLM Cost Calculator to compare API spend against running your own hardware, and our LLM Token Counter to estimate cost and context fit across many models at once.
What Changed in 2026
If you're working from a 2024 or 2025 mental model, recalibrate:
- OpenAI retired the GPT-4 line and the original GPT-5; the current family is GPT-5.5 / 5.4 / 5.4-nano, with reasoning built in via a
reasoning_effortparameter. The standalone o-series (o3, o4-mini) is sunsetting - o3 was deprecated 2026-06-11. - Anthropic is on Claude Opus 4.8 / Sonnet 4.6 / Haiku 4.5, all with "extended thinking" built in and 1M-token context on Opus and Sonnet.
- Google ships a messy but powerful lineup spanning Gemini 2.5, 3, 3.1, and 3.5 generations simultaneously, with configurable thinking levels and a "Deep Think" reasoning mode.
- Meta released Llama 4 (Scout, Maverick) - MoE, multimodal, open-weight, with Scout reaching a 10M-token context.
- DeepSeek (V3 + R1) arrived as the price-disruptor: frontier-adjacent quality at roughly a tenth of Western flagship pricing.
Cross-Provider Pricing (per 1M tokens)
Frontier Tier
| Model | Provider | Input | Output | Context | Notes |
|---|---|---|---|---|---|
| GPT-5.5 | OpenAI | $5.00 | $30.00 | 1M | >272K prompt billed 2x in / 1.5x out |
| Claude Opus 4.8 | Anthropic | $5.00 | $25.00 | 1M | Adaptive thinking; flat-rate 1M |
| Gemini 3.1 Pro | ~$2.00 | ~$12.00 | 1M | Frontier Pro tier | |
| Gemini 2.5 Pro | $1.25 | $10.00 | 1M | Steps to ~$2.50/$15 above 200K |
Mid Tier (best balance)
| Model | Provider | Input | Output | Context |
|---|---|---|---|---|
| Claude Sonnet 4.6 | Anthropic | $3.00 | $15.00 | 1M |
| GPT-5.4 | OpenAI | $2.50 | $15.00 | 1M |
| Gemini 3 Flash | $0.50 | $3.00 | 1M | |
| Mistral Medium 3 | Mistral | ~$1.00 | ~$3.00 | — |
| DeepSeek-R1 (reasoning) | DeepSeek | ~$0.55 | ~$2.19 | 128K |
Budget Tier (cost-optimized)
| Model | Provider | Input | Output | Context |
|---|---|---|---|---|
| Claude Haiku 4.5 | Anthropic | $1.00 | $5.00 | 200K |
| Gemini 2.5 Flash | $0.30 | $2.50 | 1M | |
| GPT-5.4-nano | OpenAI | $0.20 | $1.25 | — |
| Mistral Small 3 | Mistral | ~$0.10 | ~$0.30 | — |
| DeepSeek-V3 | DeepSeek | ~$0.14 | ~$0.28 | 128K |
Meta Llama 4 (Scout, Maverick) has no first-party per-token price - it's open-weight. Costs come from hosts (Together, Fireworks, Groq, Bedrock) and vary by provider and quantization.
The spread between the most expensive output (GPT-5.5 at $30) and the cheapest (DeepSeek-V3 at $0.28) is over 100x. That gap - not the headline model - is where your bill is won or lost.
<text x="182" y="96" text-anchor="end">Claude Opus 4.8</text>
<rect x="190" y="84" width="475" height="20" fill="#2813e8"/>
<text x="671" y="99">$25.00</text>
<text x="182" y="130" text-anchor="end">GPT-5.4</text>
<rect x="190" y="118" width="285" height="20" fill="#2813e8"/>
<text x="481" y="133">$15.00</text>
<text x="182" y="164" text-anchor="end">Gemini 3.1 Pro</text>
<rect x="190" y="152" width="228" height="20" fill="#2813e8"/>
<text x="424" y="167">~$12.00</text>
<text x="182" y="198" text-anchor="end">Haiku 4.5</text>
<rect x="190" y="186" width="95" height="20" fill="#2813e8"/>
<text x="291" y="201">$5.00</text>
<text x="182" y="232" text-anchor="end">Gemini 3 Flash</text>
<rect x="190" y="220" width="57" height="20" fill="#2813e8"/>
<text x="253" y="235">$3.00</text>
<text x="182" y="266" text-anchor="end">DeepSeek-R1</text>
<rect x="190" y="254" width="42" height="20" fill="#2813e8"/>
<text x="238" y="269">~$2.19</text>
<text x="182" y="300" text-anchor="end">DeepSeek-V3</text>
<rect x="190" y="288" width="6" height="20" fill="#2813e8"/>
<text x="202" y="303">~$0.28</text>
Reasoning Models and the Thinking-Token Trap
The biggest billing surprise in 2026 is reasoning tokens. Every flagship now has a "thinking" mode - OpenAI's reasoning_effort (minimal / low / medium / high), Claude's extended/adaptive thinking with a thinking budget, Gemini's thinking levels plus "Deep Think," and DeepSeek-R1's reasoning trace.
Here's the catch: those reasoning tokens are billed as output tokens, even though you never see them. A model that thinks for 4,000 tokens before emitting a 200-token answer bills you for ~4,200 output tokens. On GPT-5.5 ($30 output) that single call costs ~$0.13 versus ~$0.006 for the visible answer alone.
Practical rules:
- Default to minimal/low effort for extraction, classification, routing, and simple chat.
- Reserve high effort for genuinely hard reasoning, multi-step agentic work, and tricky debugging.
- If you're paying flagship output rates for reasoning on easy tasks, you're lighting money on fire. DeepSeek-R1 (~$2.19 output) is a far cheaper place to buy reasoning tokens when its quality suffices.
DeepSeek: The Price Floor
DeepSeek changed the math. DeepSeek-V3 (general chat) runs ~$0.14/$0.28 and DeepSeek-R1 (reasoning) ~$0.55/$2.19, both open-weight with first-party APIs at 128K context. Cache-hit input drops to ~10% of standard, and off-peak windows (16:30-00:30 GMT) discount up to 50% on V3 and 75% on R1.
For cost-sensitive, high-volume workloads where you don't need the absolute frontier, DeepSeek-V3 is often the rational default - and because the weights are open, you can self-host the exact same model for data isolation. If you want to run it on your own box, see Run DeepSeek Locally and size the hardware with our LLM VRAM Calculator.
Cost Analysis by Use Case
Chatbot / Conversational AI
Typical turn: 800 input, 400 output tokens.
| Model | Cost / 1,000 turns | Monthly (100K turns) |
|---|---|---|
| DeepSeek-V3 | $0.22 | $22 |
| GPT-5.4-nano | $0.66 | $66 |
| Gemini 3 Flash | $1.60 | $160 |
| GPT-5.4 | $8.00 | $800 |
Document Summarization
Typical: 10,000 input, 500 output tokens.
| Model | Cost / document | Monthly (10K docs) |
|---|---|---|
| DeepSeek-V3 | $0.0015 | $15 |
| Gemini 2.5 Flash | $0.0043 | $43 |
| GPT-5.4 | $0.033 | $325 |
| Claude Sonnet 4.6 | $0.038 | $375 |
Code Generation
Typical: 2,000 input, 1,000 output tokens.
| Model | Cost / request | Monthly (50K req) |
|---|---|---|
| Gemini 3 Flash | $0.004 | $200 |
| GPT-5.4 | $0.020 | $1,000 |
| Claude Sonnet 4.6 | $0.021 | $1,050 |
| Claude Opus 4.8 | $0.035 | $1,750 |
Claude Opus 4.8 and GPT-5.5 lead on coding quality; Sonnet 4.6 and Gemini 3 Flash are the value picks. Don't pay Opus rates for boilerplate.
Managed Platforms: Bedrock, Azure, Vertex
| Platform | Models | Pricing vs direct | Use when |
|---|---|---|---|
| AWS Bedrock | Claude, Llama, Mistral, others | ~Same list price; some host markup on open models | In AWS, need VPC endpoints / compliance |
| Azure OpenAI | GPT-5.x family | Matches OpenAI list | Microsoft stack, content filtering, residency |
| Vertex AI | Gemini family | Matches Google list | GCP stack, grounding with Search |
The per-token rate is rarely why you pick a platform - governance, data residency, and unified billing are. Plan Bedrock spend with our AWS Bedrock Pricing Calculator.
Self-Hosting Is Really Cloud-GPU Rental
The 2024 framing of "buy two A100s" is outdated. In practice, self-hosting open weights (Llama 4, DeepSeek, Mistral) means renting H100/H200-class GPUs by the hour and serving with vLLM or llama.cpp. The A100 is now the budget tier.
| GPU (rented) | Approx $/hr (mid-2026 range) | Holds 70B Q4? | Single-stream 70B Q4 |
|---|---|---|---|
| H200 141GB | ~$3-5 specialist | Yes, big KV headroom | ~45-65 tok/s |
| H100 80GB | ~$2-4 specialist / $5-12 hyperscaler | Yes | ~40-60 tok/s |
| 2x A100 80GB | ~$2.40-6.50 | Yes | ~25-40 tok/s |
| RTX 4090 24GB | ~$0.30-0.70 | No (needs offload) | ~15-20 tok/s |
The economics hinge on utilization. At single-stream decode, an H100 produces ~50 tok/s ≈ 0.18M tokens/hour, so at $3/hr that's ~$17 per 1M output tokens - worse than most APIs. But decode is memory-bandwidth-bound and batches beautifully: vLLM's continuous batching and PagedAttention push aggregate throughput into the thousands of tok/s under concurrent load, dropping per-token cost to cents. Self-hosting wins on steady high volume, strict data isolation, or fine-tuned models; it loses on bursty or low traffic.
Don't eyeball it - model it:
- Self-Hosted LLM Cost Calculator - API cost vs own-hardware break-even.
- What LLM Can I Run - GPU detection to model fit.
- LLM Inference Speed Calculator - estimate tok/s from bandwidth, model, and quant.
- LLM GPU Benchmark - real in-browser bandwidth and tokens/sec.
For the full hardware, quantization, and runtime picture, see Running Local AI: The Complete Guide. For a worked break-even on buying a GPU instead of paying per token, see OpenAI API vs a gaming PC.
Cost Optimization Strategies
1. Model cascading. Route by complexity - cheap model first, escalate only on low confidence.
def select_model(complexity: str) -> str:
if complexity == "simple":
return "deepseek-chat" # ~$0.14/$0.28
elif complexity == "moderate":
return "claude-sonnet-4.6" # $3/$15
return "gpt-5.5" # $5/$30
2. Prompt caching. Cached input runs ~10% of standard across providers - huge for repeated system prompts and long shared context.
3. Batch processing. ~50% off on OpenAI, Anthropic, Mistral, and others for non-interactive jobs.
4. Tokenizer efficiency. GPT-5/o-series use o200k_base (~200K vocab) versus the older cl100k_base (~100K). The bigger vocabulary packs more text per token - meaningful savings on code and non-English. Llama 3/4's 128K-vocab tokenizer narrows the same gap. Same words, fewer billed tokens.
5. Mind the reasoning budget. As covered above, thinking tokens bill as output - cap effort per task tier.
Combined, cascading + caching + batching routinely cuts 40-70% off a naive "flagship for everything" bill.
Conclusion
LLM costs span more than 100x between tiers, and the 2026 lineup makes that spread sharper, not gentler. The discipline is the same as ever, just with new names:
- Default cheap. DeepSeek-V3, Gemini Flash, GPT-5.4-nano, or Mistral Small 3 for the bulk of traffic.
- Escalate selectively. GPT-5.5, Claude Opus 4.8, or Gemini 3.1 Pro only where quality measurably pays for itself.
- Budget reasoning tokens. They bill as output - turn effort down for easy work.
- Use the levers. Caching (~10% input), batching (~50% off), and a leaner tokenizer compound.
- Decide self-hosting with numbers, not vibes - run the break-even calculator.
The best model is the one that delivers the required quality at a cost you can sustain at scale.