Posted on Jun 23, 2026 · Updated Jun 23, 2026 · 12 min read
LLM Inference Cost: Price Per 1M Tokens by Model (2026)
LLM inference is priced per token, and the spread between models is enormous. Budget-tier models serve a million output tokens for under a dollar; flagship models charge $15–$25 for the same volume. Picking the wrong model for a high-volume workload can multiply your bill 20x or more — and most teams never run the math until the invoice arrives.
This guide gives you the per-model price table, the formula to turn token prices into a real monthly bill, and the two traps that quietly inflate inference cost: output tokens costing several times more than input, and reasoning or agent workflows multiplying token counts. Prices change frequently, so treat the numbers as a snapshot and verify against each provider — the method is what stays useful.
TL;DR
LLM inference cost is set by three things: which model, the input/output token split, and how many tokens per request. Output tokens cost 4–5x input. Flagship models run $15–$25 per 1M output tokens; mid-tier ~$5–$15; budget under $1. Reasoning and agent workflows burn 5–10x the tokens of a simple completion, so total bills can climb even as per-token prices fall. Match the model to the task, not the demo.
Table of contents
How does LLM inference pricing work?
Every major LLM API charges per token, split into two meters: input tokens (your prompt, system message, and any context you send) and output tokens (the model's response). Output is almost always priced 4–5x higher than input, because generation is the expensive part. A token is roughly 0.75 words, so one million tokens is about 750,000 words.
This split matters more than the headline price. A summarization workload sends huge prompts and returns short answers — it's input-heavy, so a model with cheap input wins. A content-generation workload sends short prompts and returns long responses — it's output-heavy, so output price dominates. Two models with the same "blended" price can cost very differently on your actual traffic.
Prompt caching is the third variable. Most providers now let you cache a stable prompt prefix and pay a fraction of the input price on repeat reads. For workloads that resend the same long system prompt or document on every call, caching can cut input cost by 80–90% — often the single biggest lever on a real bill.
Price per 1M tokens by model (2026)
The table below shows representative list prices per 1 million tokens, early 2026. The Anthropic Claude figures are from Anthropic's published pricing; the others are representative tier figures, since list prices shift often. Always confirm current pricing on each provider's page before modeling a budget.
| Tier / model | Input / 1M | Output / 1M |
|---|---|---|
| Budget tier (small/fast models) | ~$0.10–$0.50 | ~$0.30–$1.50 |
| Claude Haiku 4.5 | $1.00 | $5.00 |
| Claude Sonnet 4.6 | $3.00 | $15.00 |
| Mid / flagship tier (typical) | ~$2–$5 | ~$10–$15 |
| Claude Opus 4.8 | $5.00 | $25.00 |
| Frontier / largest models | ~$10+ | ~$25–$50 |
Sources: Anthropic published pricing (2026) for Claude models; representative tier ranges from spendark analysis of published provider pricing. Verify current prices with each provider before budgeting.
How to calculate your real monthly inference bill
The formula is simple; the inputs are where teams go wrong. Per request:
cost = (input_tokens × input_price + output_tokens × output_price) / 1,000,000
Then multiply by monthly request volume. Measure real token counts — don't guess from word counts.
Worked example. Say a support-assistant feature sends a 2,000-token prompt (system message + context + user question) and returns a 500-token answer, at 100,000 requests per month. On Claude Sonnet 4.6 ($3 input / $15 output per 1M):
| Component | Calculation | Cost |
|---|---|---|
| Input (2,000 tok × 100K req) | 200M tok × $3/M | $600 |
| Output (500 tok × 100K req) | 50M tok × $15/M | $750 |
| Total / month | — | $1,350 |
Note that the 500 output tokens cost more than the 2,000 input tokens — that's the 5x output multiplier at work. Two levers immediately stand out. Switch to Claude Haiku 4.5 ($1/$5) where quality allows and the bill drops to ~$450/month. Add prompt caching on the stable part of that 2,000-token prompt and input cost falls sharply too. For the full estimation workflow across providers, see our cloud cost estimation guide.
Why reasoning and agent models cost 5-10x more
The headline price per token tells you almost nothing about an agent's bill, because agents and reasoning models consume far more tokens per task. A reasoning model generates extended internal reasoning before its answer — tokens you pay for. An agent loop adds calls for tool use, reflection, and retries, each carrying the full conversation history as input.
Here's the trap. A single chatbot reply might be 2,500 tokens total. The same task handed to an agent — read context, call a tool, evaluate the result, call another, summarize — can easily hit 15,000–25,000 tokens across the loop, because each step resends the growing history as input. That's a 5–10x multiplier on the same underlying job. Per-token prices have fallen ~80% in two years, but agentic patterns have grown token volume fast enough that many teams' total bills still climbed.
The practical defenses: cache the stable prompt prefix so repeated history reads bill at cache-read rates; use context editing or compaction to stop resending stale tool results; and route simple steps to a cheaper model while reserving the flagship for the hard reasoning. The broader picture of AI compute cost is in our state of AI infrastructure costs 2026.
When does self-hosting beat the API?
Self-hosting an open-weight model on your own GPUs charges you per GPU-hour, including idle time. A model API charges per token, with zero idle cost. So self-hosting only wins economically once your inference volume is high and steady enough to keep GPUs busy — typically above 50% utilization.
At the 23% average GPU utilization typical of real workloads (Harness, 2025), you're paying for roughly four GPUs to get the work of one — and an API is almost always cheaper, plus it removes the operational burden of running GPU infrastructure. The exceptions are data-residency or privacy requirements that prohibit sending data to a third party, where self-hosting may be mandatory regardless of the math. We work through the full decision in cloud cost management for AI/ML startups, and the GPU pricing detail is in our GPU cloud pricing guide.
How to cut LLM inference costs
The biggest savings come from the token math, not from switching providers. Here are the five highest-ROI moves, roughly in order.
1. Cache your stable prompt prefix
If you resend the same system prompt, instructions, or document on every call, prompt caching bills those repeated input tokens at a fraction of the price — often 80–90% off the cached portion. For high-volume features with a large fixed prompt, this is usually the single biggest win and requires no quality tradeoff.
2. Route by task difficulty
Not every request needs your most expensive model. Send classification, extraction, and simple Q&A to a budget model, and reserve the flagship for genuinely hard reasoning. A two-tier router can cut blended cost by half or more while keeping quality high on the requests that need it.
3. Cap output length
Output tokens cost 4–5x input, so unbounded responses are expensive. Set sensible max-output limits and prompt for concise answers where appropriate. Trimming a verbose 500-token answer to 200 tokens cuts the output cost of that request by 60%.
4. Trim and compact context
In agent loops, resending the entire growing history as input on every step is the main cost driver. Use context editing to drop stale tool results and compaction to summarize old turns, so each step pays for the context it actually needs — not the whole transcript.
5. Batch non-urgent work
For workloads that aren't latency-sensitive — bulk classification, overnight enrichment, evals — batch APIs typically run at half price. Model the savings before you commit with the spendark cloud cost calculator, and pair it with our cloud cost optimization checklist for the infrastructure around your inference stack.
Where to host your own inference
Self-hosting on a specialist GPU cloud can undercut per-token API pricing once you have steady volume.
- RunPod — serverless GPU endpoints that scale to zero — ideal for spiky inference.
- Vast.ai — lowest $/hr on the spot market for batch or background inference.
- Lambda — reserved capacity for always-on, latency-sensitive serving.
Some provider links above are affiliate links — we may earn a commission at no extra cost to you. It never affects our pricing data.
Frequently asked questions
How much does it cost to run 1 million tokens through an LLM?
It depends on the model and the input/output split. Budget models serve 1M output tokens for under $1; mid-tier models run ~$5–$15; flagship models $15–$25; frontier models up to ~$50. Input tokens cost 4–5x less than output. Claude pricing, for example, runs $1/$5 (Haiku 4.5), $3/$15 (Sonnet 4.6), and $5/$25 (Opus 4.8) per 1M input/output tokens.
Why do output tokens cost more than input tokens?
Generation is the computationally expensive part of inference — the model produces each output token sequentially, while input tokens are processed in parallel. Across major providers, output is priced roughly 4–5x higher than input. This is why output-heavy workloads (content generation) cost far more than input-heavy ones (summarization) at the same request volume.
Are LLM API prices going up or down?
Per-token prices have fallen roughly 80% in two years as providers compete and efficiency improves. But total bills often rise anyway, because reasoning models and agent workflows consume 5–10x the tokens of a simple completion. Unit prices down, token volume up — the net depends on how token-hungry your workload is.
How can I reduce my LLM API bill without losing quality?
Start with prompt caching (80–90% off repeated input), then route simple requests to a cheaper model, cap output length, and trim context in agent loops. These four levers typically cut inference cost 40–70% without changing user-facing quality. Batch non-urgent work for an additional ~50% on those jobs.
Is it cheaper to use an API or self-host an open model?
For most teams, the API is cheaper because you pay per token with zero idle cost. Self-hosting only wins once inference volume is high and steady enough to keep GPUs above ~50% utilization. At the 23% average GPU utilization typical of real workloads (Harness, 2025), the API almost always wins on cost and removes the operational burden.
Estimate your cloud costs — for free
Compare AWS, Azure, and GCP pricing side by side with our free calculator, and dig into the guides to learn how to cut cloud waste. No sign-up required.