"Per million tokens" is the unit the industry settled on, but it's an abstraction that makes it hard to reason about real costs. Let's translate it into something you can actually use.
One million tokens is roughly 750,000 words — about 10 full-length novels. You're not reading novels. You're making API calls. A typical GPT-4o request is 1,000–3,000 tokens. A million tokens is 333–1,000 of those requests.
The 2026 Pricing Table
Current list prices across the major models:
| Model | Provider | Input ($/1M) | Output ($/1M) | Context Window |
|---|---|---|---|---|
| GPT-4o | OpenAI | $2.50 | $10.00 | 128K |
| GPT-4o-mini | OpenAI | $0.15 | $0.60 | 128K |
| o1 | OpenAI | $15.00 | $60.00 | 200K |
| o3-mini | OpenAI | $1.10 | $4.40 | 200K |
| Claude Sonnet 4.5 | Anthropic | $3.00 | $15.00 | 200K |
| Claude Haiku 3.5 | Anthropic | $0.80 | $4.00 | 200K |
| Claude Opus 4 | Anthropic | $15.00 | $75.00 | 200K |
| Gemini 2.5 Flash | $0.075 | $0.30 | 1M | |
| Gemini 2.5 Pro | $1.25 | $10.00 | 1M | |
| Llama 3.1 70B (Groq) | Groq | $0.59 | $0.79 | 128K |
| Llama 3.1 70B (Together) | Together AI | $0.88 | $0.88 | 128K |
| Mistral Large 2 | Mistral | $2.00 | $6.00 | 128K |
| Mixtral 8x22B | Mistral | $1.20 | $1.20 | 64K |
These are public list prices as of mid-2026. Anthropic and OpenAI both offer volume discounts above ~$10K/month. Caching reduces effective input costs by 50–90%.
Why Output Tokens Cost 3–5x More
Input tokens are processed in parallel during the prefill phase. The model reads your entire prompt at once, building up a KV cache of attention states. This is computationally efficient — roughly O(n) work spread across GPU cores simultaneously.
Output tokens are generated sequentially. Each output token requires a full forward pass through the model. Token n+1 cannot be generated until token n is finished. This sequential process is GPU memory-bound, not compute-bound, and it's why autoregressive generation doesn't parallelize the way prefill does.
The practical implication: output tokens are genuinely more expensive to produce. The 3–5x pricing premium reflects real hardware economics, not arbitrary margin.
This means: long responses are disproportionately expensive. A 2,000-token response costs 20x more in output than a 100-token response, and likely 6–10x more in total cost (factoring in fixed input overhead). If you're prompting for detailed explanations when bullet points would suffice, you're burning money on output.
What These Numbers Look Like in Practice
Scenario 1: Customer Support Chatbot
Average request: 800 input tokens (system prompt + user message + history), 200 output tokens.
| Model | Cost per request | Cost per 100K requests/month |
|---|---|---|
| Claude Opus 4 | $0.027 | $2,700 |
| GPT-4o | $0.004 | $400 |
| Claude Sonnet 4.5 | $0.005 | $500 |
| Claude Haiku 3.5 | $0.0014 | $140 |
| Gemini 2.5 Flash | $0.00012 | $12 |
| Llama 3.1 70B (Groq) | $0.00063 | $63 |
Gemini 2.5 Flash is absurdly cheap for this use case. At 100K requests/month, the difference between using Opus and Flash is $2,688. For a customer support bot where response quality is good enough from Flash, that's hard to justify.
Scenario 2: Code Review Tool
Average request: 4,000 input tokens (code + context + instructions), 1,500 output tokens.
| Model | Cost per review | Cost per 10K reviews/month |
|---|---|---|
| Claude Opus 4 | $0.1725 | $1,725 |
| GPT-4o | $0.025 | $250 |
| Claude Sonnet 4.5 | $0.0345 | $345 |
| Gemini 2.5 Pro | $0.020 | $200 |
| Llama 3.1 70B (Groq) | $0.0035 | $35 |
Here the quality gap matters. Llama 70B on Groq is $35/month for 10K code reviews, but may miss subtle issues that Sonnet or GPT-4o would catch. This is a decision you need to make with real quality evals, not assumptions.
Context Window Costs
Long context is a multiplier on everything. If you're stuffing a 50,000-token document into every request:
- GPT-4o: 50,000 × $2.50/M = $0.125 per request before output
- Gemini 2.5 Flash: 50,000 × $0.075/M = $0.00375 per request before output
For document processing at any scale, Gemini 2.5 Flash's 1M context window at near-zero input pricing is a significant structural advantage.
Where Provider Pricing Diverges Most
Reasoning models (o1, o3) charge for "thinking tokens" — internal chain-of-thought that you don't see but do pay for. An o1 call that looks like 1,000 input + 500 output might internally generate 3,000 reasoning tokens. Effective cost per visible output token is often 3–5x the listed price.
Anthropic's output pricing is the steepest among frontier models. Claude Opus 4 at $75/M output is 7.5x GPT-4o's output rate. For applications with long, detailed outputs, this matters enormously.
Groq's pricing is attractive on Llama 70B but comes with rate limits. At peak times you'll hit 30 req/min per API key. Fine for moderate workloads, problematic for high-throughput applications.
Together AI offers spot pricing for batch workloads that can cut costs another 30–50% if you can tolerate 30–60 second latency. Worth knowing about for offline processing jobs.
Translating to Real Budget Numbers
If someone on your team says "we'll process 10 million tokens per month," here's how to translate that quickly:
- At GPT-4o blended (60% input, 40% output): ~$5,500/month
- At Claude Sonnet 4.5 blended: ~$7,800/month
- At Gemini 2.5 Flash blended: ~$165/month
- At Llama 3.1 70B on Groq: ~$710/month
The right model for 10M tokens/month depends entirely on what quality you need. If Gemini Flash passes your quality bar, you're looking at $165 vs $5,500 — a 33x difference for the same volume. Run the evals before you commit to the expensive option.