Vibe Engines is free, interactive AI engineering & system design — runs in your browser. Pick a learning path →
LLM API pricing, in one place
Every provider publishes its own pricing page, in its own format, with its own naming scheme — and a search for "GPT pricing" or "Claude pricing" mostly surfaces aggregator blogs that get the model names and numbers wrong. This page pulls current pricing directly from each provider's official docs, normalized into one comparable table.
As of October 28, 2026: the cheapest current models are Google's Gemini 2.5 Flash-Lite at $0.10/$0.40 per million input/output tokens, then Claude Haiku 5.5 (prompts up to 100K tokens) and OpenAI's gpt-6-luna, both at $0.10/$0.50. At the top end, Claude Fable 5.1 and gpt-6-astra are both $10/$50, and Gemini 4 Argon is $2/$10 through November 30, 2026 ($4/$20 from December 1). All three providers offer roughly a 50% discount for asynchronous batch processing and 90% or more off cached, repeated input tokens on the models listed here.
Methodology — why this table exists
Researching this page meant running the obvious searches — "Claude API pricing", "OpenAI API pricing per million tokens" — and the results were a mess: aggregator sites citing model names that don't exist, prices attributed to the wrong tier, and numbers contradicting each other across the first page of results. That's not a knock on any one site; it's what happens when pricing changes every few months and nobody re-verifies the scraped table.
Every number on this page was pulled directly from each provider's own current pricing documentation, not a third-party summary. Where a provider's docs give conflicting numbers for the same model (introductory vs. standard pricing, context-length tiers), both are shown with the condition that applies.
Every provider here has changed pricing multiple times in the past year. Treat this table as a snapshot dated October 28, 2026, verify against the linked official docs before budgeting a production system, and don't trust a pricing number that doesn't cite where it came from — including this one.
Anthropic — Claude API pricing
Cache read pricing is 10% of the base input rate on most Claude models — a cache hit costs a tenth of processing that same content fresh — and less on the newest: 5% on Opus 5.5 and Sonnet 5.5, 2.5% on Fable 5.1. Cache writes cost more than base input (1.25x for a 5-minute cache, 2x for a 1-hour cache), so caching only pays off once content is actually reused across calls, not on a single-shot prompt. Sonnet 5's $2/$10 was announced as introductory pricing through August 31, 2026; Anthropic has since made it the standard price, and the rise to $3/$15 scheduled for September 1 did not happen. Haiku 5.5 is the one current Claude model priced by prompt length: a prompt over 100,000 tokens pays 5× the rate. Source: Anthropic's official pricing docs.
| Model | Input | Output | Batch (in/out) | Cache read |
|---|---|---|---|---|
| Claude Fable 5.1 | $10/MTok | $50/MTok | $5 / $25 | $0.25/MTok |
| Claude Fable 5 | $10/MTok | $50/MTok | $5 / $25 | $1/MTok |
| Claude Opus 5.5 | $4/MTok | $20/MTok | $2 / $10 | $0.20/MTok |
| Claude Opus 4.8 | $5/MTok | $25/MTok | $2.50 / $12.50 | $0.50/MTok |
| Claude Sonnet 5.5 | $2/MTok | $10/MTok | $1 / $5 | $0.10/MTok |
| Claude Sonnet 5 | $2/MTok | $10/MTok | $1 / $5 | $0.20/MTok |
| Claude Haiku 5.5 (prompts ≤100K) | $0.10/MTok | $0.50/MTok | $0.05 / $0.25 | $0.01/MTok |
| Claude Haiku 5.5 (prompts >100K) | $0.50/MTok | $2.50/MTok | $0.25 / $1.25 | $0.05/MTok |
| Claude Haiku 4.5 | $1/MTok | $5/MTok | $0.50 / $2.50 | $0.10/MTok |
OpenAI — API pricing
The Batch API cuts every model's pricing above by 50%, for requests that can tolerate asynchronous processing instead of a live response. The -pro tier (gpt-5.5-pro, and gpt-5.4-pro at the same rate) is a distinct, much more expensive reasoning tier — 6x the input cost and 6x the output cost of gpt-5.5 ($5/$30). Rates shown are for prompts up to 272K input tokens; above that the flagships charge more (gpt-6.1-sol goes from $2/$10 to $4/$15). gpt-5.6-sol's rate is promotional, available at least through November 21, 2026. Source: OpenAI's official pricing docs.
| Model | Input | Cached Input | Output |
|---|---|---|---|
| gpt-6-astra | $10/MTok | $1.00/MTok | $50/MTok |
| gpt-6.1-sol | $2/MTok | $0.10/MTok | $10/MTok |
| gpt-6-sol | $2/MTok | $0.20/MTok | $10/MTok |
| gpt-6.1-terra | $1/MTok | $0.05/MTok | $5/MTok |
| gpt-6-luna | $0.10/MTok | $0.01/MTok | $0.50/MTok |
| gpt-5.6-sol (promotional) | $4/MTok | $0.40/MTok | $20/MTok |
| gpt-5.5-pro | $30/MTok | — | $180/MTok |
| gpt-5.5 | $5/MTok | $0.50/MTok | $30/MTok |
| gpt-5.6-terra | $2/MTok | $0.20/MTok | $12/MTok |
| gpt-5.4 | $2.50/MTok | $0.25/MTok | $15/MTok |
| gpt-5.4-mini | $0.75/MTok | $0.075/MTok | $4.50/MTok |
| gpt-5.6-luna | $0.20/MTok | $0.02/MTok | $1.20/MTok |
| gpt-5.4-nano | $0.20/MTok | $0.02/MTok | $1.25/MTok |
Google — Gemini API pricing
Gemini's Pro-tier models step to a higher rate once a request exceeds 200K input tokens. OpenAI's flagships do the same above 272K, and Anthropic only on Haiku 5.5 (above 100K); Claude's other current models bill their full context window at the standard rate. Batch processing is 50% off across all models. Two of Google's newest models are on launch pricing that doubles: Gemini 4 Argon on December 1, 2026 (to $4/$20) and Gemini 3.8 Flash and 3.6 Flash on January 1, 2027 (to $1.50/$7.50). Gemini 3.5 Flash is no longer priced on its own: its endpoint now routes to Gemini 3.6 Flash. Gemini 2.5 Flash-Lite, the cheapest row, has no shutdown date announced; Google says the 2.5 models will be served until further notice. Source: Google's official Gemini API pricing.
| Model | Input | Cache | Output |
|---|---|---|---|
| Gemini 4 Argon (to Nov 30, 2026) | $2.00/MTok | $0.10/MTok | $10.00/MTok |
| Gemini 3.1 Pro Preview (≤200K) | $2.00/MTok | $0.20/MTok | $12.00/MTok |
| Gemini 3.1 Pro Preview (>200K) | $4.00/MTok | $0.40/MTok | $18.00/MTok |
| Gemini 2.5 Pro (≤200K) | $1.25/MTok | $0.125/MTok | $10.00/MTok |
| Gemini 3.8 Flash (to Dec 31, 2026) | $0.75/MTok | $0.075/MTok | $3.75/MTok |
| Gemini 3.6 Flash (to Dec 31, 2026) | $0.75/MTok | $0.075/MTok | $3.75/MTok |
| Gemini 2.5 Flash | $0.30/MTok | $0.03/MTok | $2.50/MTok |
| Gemini 3.5 Flash-Lite | $0.30/MTok | $0.03/MTok | $2.50/MTok |
| Gemini 3.1 Flash-Lite | $0.25/MTok | $0.025/MTok | $1.50/MTok |
| Gemini 2.5 Flash-Lite | $0.10/MTok | $0.01/MTok | $0.40/MTok |
Cross-provider tier comparison
Normalizing three different naming schemes into one table by capability tier:
| Tier | Anthropic | OpenAI | |
|---|---|---|---|
| Frontier / reasoning | Claude Fable 5.1 — $10/$50 | gpt-6-astra — $10/$50 | Gemini 4 Argon — $2/$10* |
| Flagship | Claude Opus 5.5 — $4/$20 | gpt-6.1-sol — $2/$10 | Gemini 3.1 Pro Preview — $2/$12 |
| Balanced | Claude Sonnet 5.5 — $2/$10 | gpt-6.1-terra — $1/$5 | Gemini 3.8 Flash — $0.75/$3.75* |
| Fast / budget | Claude Haiku 5.5 — $0.10/$0.50† | gpt-6-luna — $0.10/$0.50 | Gemini 3.5 Flash-Lite — $0.30/$2.50 |
| Ultra-budget | — | — | Gemini 2.5 Flash-Lite — $0.10/$0.40 |
*Launch pricing: Gemini 4 Argon is $2/$10 through November 30, 2026 and $4/$20 from December 1; Gemini 3.8 Flash is $0.75/$3.75 through December 31, 2026 and $1.50/$7.50 from January 1, 2027. †Haiku 5.5's rate for prompts up to 100,000 tokens; longer prompts pay $0.50/$2.50. This table exists to make providers comparable — it does not mean the models perform equivalently at each tier; check the evals, not just the price, before picking one.
A fully worked cost example
Take a concrete workload: a RAG chatbot serving 10,000 queries/day, averaging 2,000 input tokens (retrieved context + question) and 400 output tokens per query. That's 20M input tokens and 4M output tokens per day. Using Anthropic's published rates (the same math applies to any provider's published rates):
| Model | No caching | With caching* | Savings |
|---|---|---|---|
| Claude Haiku 5.5 | $4.00/day | $2.65/day | 34% ($493/yr) |
| Claude Haiku 4.5 | $40.00/day | $26.50/day | 34% ($4,928/yr) |
| Claude Sonnet 5 | $80.00/day | $53.00/day | 34% ($9,855/yr) |
| Claude Opus 4.8 | $200.00/day | $132.50/day | 34% ($24,638/yr) |
Assumes 1,500 of each query's 2,000 input tokens are a reused system prompt + retrieved context (cached at 0.1× base input price), with the remaining 500 tokens unique per query. The ~34% savings holds across every tier because it's driven by the fixed cached-token fraction, not the model's price — caching helps proportionally regardless of which model you're running.
The trend: capability per dollar, not price per token
It's tempting to say "token prices always fall" — the data doesn't cleanly support that as a straight line. In July 2024, OpenAI's GPT-4o mini launched at $0.15/$0.60 per million tokens, about 60% cheaper than GPT-3.5 Turbo's blended rate a year earlier (~$2/MTok blended, per contemporaneous reporting on the launch). As recently as July 2026, OpenAI's cheapest current tier, gpt-5.4-nano, was priced at $0.20/$1.25 — higher on input than 2024's GPT-4o mini was. Its newest small model, gpt-6-luna, is $0.10/$0.50: lower again, but by a third, not by an order of magnitude.
The more accurate claim is narrower and more useful: capability per dollar has risen sharply, even where the literal cheapest-tier list price hasn't kept falling in a straight line. gpt-5.4-nano in 2026 is a meaningfully more capable model than GPT-4o mini was in 2024, at a price in the same order of magnitude — the honest framing is "similar spend buys much more," not "spend keeps shrinking."
The picture: where the money goes in one request
Worked example: four levers on one monthly bill
A support assistant handles 300,000 requests a month. Each one sends 3,000 input tokens, of which 2,400 are a fixed system prompt and tool definitions that never change, and gets 500 tokens back. Start on Claude Sonnet 5 at its standard $2/$10 and pull one lever per row. Input and output are kept apart, because the levers hit them differently.
| Step | Lever | Input $ | Output $ | Month | vs list |
|---|---|---|---|---|---|
| 1 | List price: 900M in × $2, 150M out × $10 | $1,800 | $1,500 | $3,300 | — |
| 2 | Cache the 2,400-token prefix: 720M at $0.20, 180M fresh at $2 | $504 | $1,500 | $2,004 | −39.3% |
| 3 | Cap answers at 300 tokens: 90M out × $10 | $504 | $900 | $1,404 | −57.5% |
| 4 | Route 60% of requests to Haiku 4.5 ($1 / $0.10 cached / $5) | $352.80 | $630 | $982.80 | −70.2% |
Read the table as a sequence of “what is the biggest number now?”. After step 2, output is $1,500 of $2,004, about 75% of the bill, so a cheaper input rate could not help much more and shortening answers is the next lever. Step 2 also has a cost the row leaves out: cache writes at 1.25× input, or $2.50 per million on Sonnet 5. Even if the prefix were rewritten every five minutes all month (8,640 writes of 2,400 tokens), that is $51.84, small next to the $1,296 caching saved. Step 4 depends on a number only your evals can give you, which is the share of traffic the smaller model answers well. The 60% here is an assumption, not a measurement.
Cost levers and their trade-offs
Here Time means what the lever does to latency, and Space means what it does to the bill.
| Case | Time | Space | Why |
|---|---|---|---|
| Prompt caching | Often faster on a hit: the cached prefix is not reprocessed | Cache reads at 10% of input on most models, 5% or less on the newest (Claude Opus 5.5, Sonnet 5.5, Fable 5.1; gpt-6.1). Anthropic charges 1.25× (5 min) or 2× (1 hour) to write | Pays only when the same prefix is reused. A one-shot prompt pays the write premium for nothing. |
| Batch API | Asynchronous: results come back later, not in the request | 50% off input and output at all three providers | Free money for anything nobody is waiting on: evals, backfills, nightly summaries. |
| Shorter output | Faster: every output token is a sequential decode step | Output costs 4× to over 8× input across the tables | The cheapest token is the one you never generate. Ask for the format, not an essay. |
| Smaller tier | Usually faster | Haiku 4.5 is 1/5 of Opus 4.8 per token; gpt-6-luna is 1/20 of gpt-6.1-sol | The quality risk is real. Route by measured accuracy, not by hope. |
| Long context on Gemini Pro | Slower: more tokens to process | Gemini 3.1 Pro over 200K: 2× input ($4 vs $2) and 1.5× output ($18 vs $12) | Retrieval that sends 30K relevant tokens usually beats stuffing 250K. |
The levers multiply rather than add, and their order matters only for reading the bill: caching cuts input, length caps and routing cut output, batch cuts both. The one lever with a latency cost is batch. The one with a quality risk is routing. Everything else is close to free.
Common mistakes when budgeting tokens
- Comparing models on the input price alone
Input is the number people quote, but output is priced 4× (Gemini 2.5 Flash-Lite) to over 8× (Gemini 2.5 Flash) higher in the tables above. Gemini 3.1 Pro Preview, gpt-6.1-sol, Claude Sonnet 5 and gpt-5.6-terra all quote $2 per million input tokens, but their output rates are $12, $10, $10 and $12, so on an output-heavy workload the headline tells you nothing about which is cheaper. Price your real request shape, not the headline.
- Breaking the cache with a changing prefix
Caching matches the prompt from its first token. A timestamp, a request ID or the user’s name at the top of the system prompt makes every prefix unique, so you pay full input price, and on Anthropic a write premium on top. Put the static parts first (instructions, tool definitions, few-shot examples) and the per-request parts last.
- Forgetting the output you never see
Reasoning models bill their thinking tokens as output tokens, even when the API does not return the text. A 300-token answer that took 3,000 tokens of reasoning is billed as 3,300 output tokens. Log the usage fields the API returns and budget on those, not on the length of the visible reply.
- Budgeting on a price with an end date
Several current rates are dated. Gemini 3.8 Flash is $0.75/$3.75 through December 31, 2026 and $1.50/$7.50 from January 1, 2027, so the page’s 10,000-queries-a-day chatbot goes from $30/day to $60/day overnight. Gemini 4 Argon doubles on December 1, 2026, and gpt-5.6-sol’s promotional rate is only promised through November 21, 2026. End dates can move the other way too: Sonnet 5’s $2/$10 was announced as introductory, and Anthropic later made it the standard price. Retirements move prices as well: Gemini 3.1 Flash-Lite is scheduled to shut down on May 7, 2027, and its listed replacement, Gemini 3.5 Flash-Lite, costs 1.2× on input and about 1.7× on output.
- Assuming a token is a token
Each provider has its own tokenizer, so the same text becomes a different number of tokens on each. A per-million price only compares fairly once you count your own sample text with each provider’s tokenizer or usage fields. Code, non-English text and JSON vary most.
Where this shows up in production and interviews
- Unit economics
Finance does not think in tokens. It thinks in cost per conversation, per document or per seat. Turn the rate card into one of those (step 1 above is $0.011 per request) and set an alert on it. A prompt change that doubles the system prompt shows up there on day one, not at the end of the month.
- Model routing
A router or gateway sends easy requests to a small tier and hard ones to a flagship. Step 4 is its whole business case. The price gap sets how much routing can save (5× between Haiku 4.5 and Opus 4.8), and the share of traffic the small model handles well sets how much it does save.
- System design interviews
“What would this cost to run?” is a standard follow-up. State the volume, then input and output tokens separately, then the rate, then the levers, which is exactly the page’s 10,000-queries-a-day example. Interviewers listen for whether you price output separately and whether you mention caching and batch.
- Vendor reviews and migrations
Prices are dated snapshots, and models retire. Keep the provider and model name as configuration, not code, and rerun your cost model whenever a provider changes its rate card. Then a price change becomes a config edit and a re-forecast, not a surprise invoice.
Check yourself
A request sends 10,000 input tokens to Claude Opus 4.8 and gets 1,000 back. What does it cost, live and through the Batch API?
Live: 10,000 × $5/M = $0.05 of input plus 1,000 × $25/M = $0.025 of output, so $0.075. Batch halves both rates ($2.50 / $12.50), so $0.0375.
From January 1, 2027, Gemini 3.8 Flash is $1.50/$7.50. Against Gemini 2.5 Pro ($1.25/$10), which is cheaper?
It depends on the request shape. At 1,000 in / 1,000 out, Pro costs $0.01125 and Flash $0.009, so Flash wins. At 10,000 in / 200 out, Pro costs $0.0145 and Flash $0.0165, so Pro wins. They cost the same when output is a tenth of input: Flash saves $2.50 per million output tokens and costs $0.25 more per million input tokens. Until December 31, 2026, Flash is $0.75/$3.75 and wins both shapes.
On Anthropic, a 5-minute cache write costs 1.25× input and a read costs 0.1×. How many uses before caching a prefix pays off?
Two. One use costs 1.25× against 1× uncached, which loses. Two uses cost 1.25 + 0.1 = 1.35× against 2×, which wins. With the 1-hour cache (2× to write), two uses cost 2.1× against 2× and still lose; it takes three (2.2× against 3×).
Claude Sonnet 5.5 has the same $2/$10 rates as Sonnet 5 but reads cache at $0.10 instead of $0.20. What does the page’s chatbot ($80 a day uncached, $53 cached on Sonnet 5) cost on it?
Uncached it is the same $80/day. With caching: 15M × $0.10 + 5M × $2 + 4M × $10 = $51.50/day, only $1.50 less than on Sonnet 5. Halving the cache-read rate barely moves the bill, because cached input was already its smallest part: output is $40 of the $51.50.
Quick answers
Which LLM API is cheapest?
At the ultra-budget tier, Google’s Gemini 2.5 Flash-Lite is currently cheapest at $0.10/$0.40 per million input/output tokens. Claude Haiku 5.5 (for prompts up to 100,000 tokens) and OpenAI’s gpt-6-luna are close behind at $0.10/$0.50.
How much does prompt caching actually save?
It depends on what fraction of your input is reused across calls, but cache reads cost 10% of the base input rate on most Anthropic and OpenAI models, and 5% or less on the newest ones. In the worked example on this page, a 75%-cached-input chatbot workload saw a consistent ~34% total cost reduction across every model tier.
Is the Batch API worth using?
For any workload that doesn’t need a live response — nightly summarization, bulk classification, offline evals — yes: it’s a flat 50% discount on both input and output tokens across all three providers, with no other trade-off besides asynchronous delivery.
Why do third-party pricing pages often show wrong numbers?
Pricing changes every few months across a rapidly expanding set of model names, and most aggregator content is written once and rarely re-verified — several sources checked while researching this page cited model names or prices that didn’t match the providers’ own current documentation.
Explore the topic
See this alongside everything else on the same subject — handbooks, system designs, challenges and tools, in one place.
More Handbooks
- The Prompting HandbookA friendly, hands-on field guide for everyday humans — learn the CRISP framework, spot bad prompts, practice with real recipes, play a drag-and-drop game, and test yourself with a quiz. No code required.Read →
- The Senior AI Engineer Interview Handbook60 questions across architecture, production incidents, agentic systems, RAG, evals, cost, safety, and leadership — what staff-level AI interviewers actually probe for.Read →
- The LLM Serving HandbookHow to serve large language models fast and cheap — prefill vs decode, the KV cache, continuous batching and PagedAttention (vLLM), quantization, speculative decoding, and the latency-vs-throughput tradeoffs that decide your inference bill.Read →
- The Transformers HandbookThe architecture behind every LLM, built up from scratch — tokens and embeddings, positional encoding, self-attention (query/key/value), multi-head attention, the transformer block (FFN, residuals, layer norm), and how a decoder-only model generates text autoregressively.Read →
- The Fine-Tuning HandbookWhen to fine-tune vs RAG vs prompting, full fine-tuning vs parameter-efficient methods, how LoRA and QLoRA make it cheap enough for a single GPU, why the data matters more than the method, catastrophic forgetting, and how to evaluate and decide.Read →
- The On-Device AI HandbookSmall models, everywhere: why 1–14B models got frontier-adjacent (distillation + textbook data), the napkin law of local inference (tokens/sec ≈ bandwidth ÷ bytes), quantization and the llama.cpp / GGUF / Ollama / MLX stack, the honest local-vs-cloud decision table, four hybrid patterns that ship, and the evals craft of choosing a small model that actually fits the device.Read →