Anthropic's price list for the Claude API fits on one screen: a handful of models, each with a price for input tokens and a price for output tokens. What that screen does not show is that a real request is billed across five different token prices — fresh input, two kinds of cache write, cache read, and output — and that the same request can cost anywhere from $0.014 to $0.031 on the same model depending on which of those five it lands on. Add the Batch API, the tokenizer change in the 4.7 generation, the per-search fee for web search, and the small system prompt the API adds when you use tools, and the sticker price turns out to be the least informative number on the page.
This guide reads the whole price table line by line, at the rates published on September 21, 2026, and works each line into a request you would actually send. The short version: output is five times the price of input everywhere, a cache read is a tenth of the price of fresh input (a fortieth on Claude Fable 5.1), and the Batch API halves both — so the cheapest request is one that reads a cached prefix, writes little, and does not need an answer this minute.
The price tableFive prices per model, not two
Claude Fable 5.1
- Input
- $10
- Cache write, 5 min
- $12.50
- Cache write, 1 hour
- $20
- Cache read
- $0.25
- Output
- $50
- Batch in / out
- $5 / $25
Claude Opus 5
- Input
- $5
- Cache write, 5 min
- $6.25
- Cache write, 1 hour
- $10
- Cache read
- $0.50
- Output
- $25
- Batch in / out
- $2.50 / $12.50
Claude Sonnet 5
- Input
- $2
- Cache write, 5 min
- $2.50
- Cache write, 1 hour
- $4
- Cache read
- $0.20
- Output
- $10
- Batch in / out
- $1 / $5
Claude Sonnet 4.6
- Input
- $3
- Cache write, 5 min
- $3.75
- Cache write, 1 hour
- $6
- Cache read
- $0.30
- Output
- $15
- Batch in / out
- $1.50 / $7.50
Claude Haiku 4.5
- Input
- $1
- Cache write, 5 min
- $1.25
- Cache write, 1 hour
- $2
- Cache read
- $0.10
- Output
- $5
- Batch in / out
- $0.50 / $2.50
| Model | Input | Cache write, 5 min | Cache write, 1 hour | Cache read | Output | Batch in / out |
|---|---|---|---|---|---|---|
| Claude Fable 5.1 | $10 | $12.50 | $20 | $0.25 | $50 | $5 / $25 |
| Claude Opus 5 | $5 | $6.25 | $10 | $0.50 | $25 | $2.50 / $12.50 |
| Claude Sonnet 5 | $2 | $2.50 | $4 | $0.20 | $10 | $1 / $5 |
| Claude Sonnet 4.6 | $3 | $3.75 | $6 | $0.30 | $15 | $1.50 / $7.50 |
| Claude Haiku 4.5 | $1 | $1.25 | $2 | $0.10 | $5 | $0.50 / $2.50 |
Source: CalculatorAI · calculatorai.app · platform.claude.com/docs/en/about-claude/pricing, read 2026-09-21
Three ratios hold across the whole table and are worth memorising, because they survive the next price change better than any dollar figure.
5× on every model — a token the model writes costs five tokens it reads0.1× (a tenth) on every model except Claude Fable 5.1, where it is 0.025× (a fortieth)1.25× for a 5-minute entry, 2× for a 1-hour entry0.5× on input and output, stacking with the cache multipliersInput and outputWhere a request's money actually goes
Because output costs five times input, the shape of a request matters more than its size. A request that reads a long document and answers in a sentence is an input-shaped request; a request that asks for a 3,000-word draft from a one-line prompt is output-shaped, and it is the output that pays the bill.
1,000 (a long paragraph)
- Request cost
- $0.030
- Share that is output
- 83%
4,000 (a short article)
- Request cost
- $0.105
- Share that is output
- 95%
16,000 (a long report)
- Request cost
- $0.405
- Share that is output
- 99%
| Output tokens | Request cost | Share that is output |
|---|---|---|
| 1,000 (a long paragraph) | $0.030 | 83% |
| 4,000 (a short article) | $0.105 | 95% |
| 16,000 (a long report) | $0.405 | 99% |
Source: CalculatorAI · calculatorai.app · drafts/claude-api-pricing-numbers.mjs
Two practical consequences. First, max_tokens is a cost control as much as a safety limit: a request that could run to 16,000 tokens is a 40-cent request on Opus 5 whether or not you needed that much. Second, extended thinking is billed as output. On the current models thinking is adaptive and you steer it with an effort setting rather than a token budget; a higher effort level is, in billing terms, a request that writes more. Our four numbers behind an AI bill guide covers the same trade-off across providers.
Prompt cachingThe line that changes everything
Most production requests carry a prefix that never changes: a system prompt, a set of tool definitions, a document, the earlier turns of a conversation. Prompt caching stores that prefix on Anthropic's side and bills later requests a tenth of the input price to reuse it. It is the single largest lever on a Claude bill, and it has exactly three prices.
The write — 1.25× or 2× base input, once
The first request that sends the prefix with a cache marker pays a premium to store it: $6.25 per million on Opus 5 for a 5-minute entry, $10 for a 1-hour entry. This is the only request that costs more than an uncached one. There are two ways to mark the prefix: a single top-level cache_control field, which places the breakpoint automatically, or explicit markers on individual content blocks, up to four per request.
The read — 0.1× base input, every time after
Every later request whose prefix is byte-identical reads it at $0.50 per million on Opus 5, $0.20 on Sonnet 5, $0.10 on Haiku 4.5 — and $0.25 on Claude Fable 5.1, which alone bills reads at a fortieth of its $10 input price. A read also refreshes the entry's timer, so steady traffic keeps a 5-minute cache alive indefinitely.
The miss — full price, and the write again
Any change anywhere in the prefix invalidates everything after it. A timestamp in the system prompt, a tool list in a different order, a reordered JSON key — each turns every request back into a write. The response's usage block reports cache_read_input_tokens; if it is zero on repeated requests, something in the prefix is changing.
The break-even is short. Against N identical requests, the uncached prefix costs N times its input price; a 5-minute cache costs 1.25 + 0.1 × (N − 1); a 1-hour cache costs 2 + 0.1 × (N − 1).
1
- Uncached
- 1.00×
- 5-minute cache
- 1.25×
- 1-hour cache
- 2.00×
2
- Uncached
- 2.00×
- 5-minute cache
- 1.35×
- 1-hour cache
- 2.10×
3
- Uncached
- 3.00×
- 5-minute cache
- 1.45×
- 1-hour cache
- 2.20×
5
- Uncached
- 5.00×
- 5-minute cache
- 1.65×
- 1-hour cache
- 2.40×
10
- Uncached
- 10.00×
- 5-minute cache
- 2.15×
- 1-hour cache
- 2.90×
| Requests | Uncached | 5-minute cache | 1-hour cache |
|---|---|---|---|
| 1 | 1.00× | 1.25× | 2.00× |
| 2 | 2.00× | 1.35× | 2.10× |
| 3 | 3.00× | 1.45× | 2.20× |
| 5 | 5.00× | 1.65× | 2.40× |
| 10 | 10.00× | 2.15× | 2.90× |
Source: CalculatorAI · calculatorai.app · drafts/claude-api-pricing-numbers.mjs
Which TTL to choose is a question about the gap between requests, not about traffic volume. Requests that share a prefix and arrive less than five minutes apart keep the 5-minute entry warm for free; the 1-hour entry only earns its doubled write price when there are gaps of five to sixty minutes between requests that would otherwise miss. There is also a minimum: prefixes below a model-specific length (512 tokens on Opus 5, 1,024 on Sonnet 5, 4,096 on Haiku 4.5) are silently not cached — no error, just a zero in cache_creation_input_tokens.
3,000-token system prompt, 500-token question, 400-token answer
The same request on four models, uncached and with the system prompt read from cache. The first cached request costs slightly more than uncached (it pays the write); every one after that costs about half. At 10,000 replies a month the cache is the difference between $275 and $140 on Opus 5.
The saving is capped near 50% in this example only because the 400-token answer is not cacheable and costs five times its length in input. On a request with a bigger prefix and a shorter answer — a 60,000-token coding context writing 2,000 tokens — the cut is closer to 70%, as our cost-per-task comparison shows; on a request stuffed with tool definitions it is over 90%, which is the whole subject of our MCP token cost guide.
The Batch APIHalf price for waiting
The Message Batches API takes a file of requests, processes them asynchronously within a window of up to 24 hours, and bills input and output at half the standard rate — $2.50 / $12.50 on Opus 5, $1 / $5 on Sonnet 5, $0.50 / $2.50 on Haiku 4.5. Nothing about the models changes; only the delivery time does. Anything that is not answering a person in real time — nightly classification, document extraction, evaluation runs, generating a month of content — belongs in a batch.
The pricing page says the batch discount and the cache multipliers stack. On a job with a shared prefix, that stacking is where the largest saving in this article comes from:
Uncached, real time
- Total
- $21.60
- vs uncached, real time
- —
Batch, uncached
- Total
- $10.80
- vs uncached, real time
- −50%
Cached, real time
- Total
- $3.71
- vs uncached, real time
- −83%
Batch + cached
- Total
- $1.86
- vs uncached, real time
- −91%
| Setup | Total | vs uncached, real time |
|---|---|---|
| Uncached, real time | $21.60 | — |
| Batch, uncached | $10.80 | −50% |
| Cached, real time | $3.71 | −83% |
| Batch + cached | $1.86 | −91% |
Source: CalculatorAI · calculatorai.app · drafts/claude-api-pricing-numbers.mjs
Treat the last row as a floor rather than a guarantee: requests inside a batch are processed independently, so how many of them actually read the cache depends on how the batch is scheduled, and the first request that stores the document always pays the write. Even so, the order of the levers is clear — cache first, batch second, model choice third — because the first two cut the bill by 80–90% with no change to the answers.
The tokenizerWhy a cheaper model can bill more tokens
The price table quotes dollars per million tokens, and a token is a property of the model's tokenizer, not of your text. Anthropic's pricing page states that Claude 4.7 and later models use a newer tokenizer that produces approximately 30% more tokens for the same text; Sonnet 4.6 and earlier use the previous one. So Sonnet 5 at $2 / $10 is not 33% cheaper than Sonnet 4.6 at $3 / $15 — on the same text it bills about 1.3 times the tokens.
1,000 tokens in, 300 out
At $3 and $15 per million: $0.0075 for the request. The token count is the one you will see if you have been measuring prompts on an older model.
About 1,300 tokens in, 390 out
At $2 and $10 per million: $0.0065. Still cheaper — by 13%, not 33%. In price-per-old-token terms Sonnet 5 costs about $2.60 in and $13 out. The same 1.3× applies to Opus 5 and Fable 5.1 against Opus 4.6 and earlier.
The exact multiplier depends on the content — code and non-English text differ from English prose — and the count_tokens endpoint returns the real number for any prompt before you send it, free of charge. When comparing models, compare the cost of your prompt, not the rate card.
The rest of the billSix smaller lines
Long context is standard price
The 1-million-token window on Claude 4.6 and later is billed at the same per-token rate whether the request is 9,000 tokens or 900,000. A 900,000-token prompt on Opus 5 is $4.50 fresh — or $0.45 read from cache, which is the only sensible way to send one twice.
Tools add a system prompt you did not write
When a request includes tools, the API prepends its own instructions: 286 tokens on Opus 5, 354 on Sonnet 5, 496 on Haiku 4.5 (more if tool choice is forced). Plus the tool definitions themselves, plus every tool call and result. At $5 per million the 286 tokens are $0.0014 a request — $143 across 100,000 requests — and the definitions are usually far larger, which is why they belong in the cached prefix.
Web search is $10 per 1,000 searches
A cent a search, on top of the tokens the results add to the context — and those results are input tokens on every later turn of the conversation too. Web fetch has no per-use fee; you pay only for the fetched content as input, so cap it with max_content_tokens.
Code execution is free with web tools, metered without
Alongside web search or web fetch there is no charge beyond tokens. On its own it is billed by container time after 1,550 free hours a month, at $0.05 per hour, with a five-minute minimum per session.
US-only inference costs 10% more
Pinning a request to US inference with inference_geo: 'us' multiplies every token price — input, output, cache writes and reads — by 1.1. The default global routing is standard price.
Fast mode is double
The research-preview fast mode on Opus 5 and Opus 4.8 runs the same model at higher output speed for $10 / $50 per million — twice the standard rate, with the cache multipliers applied on top. It is a latency purchase, and it is not available through the Batch API.
Putting it togetherOne request, priced five ways
The same 3,500-token request with a 400-token answer on Claude Opus 5, depending on how it is sent:
Fast mode, uncached
- Cost
- $0.055
- Why
- 2× rates
US-only inference, uncached
- Cost
- $0.030
- Why
- 1.1× rates
Standard, uncached
- Cost
- $0.0275
- Why
- the sticker price
Standard, prefix read from cache
- Cost
- $0.014
- Why
- 3,000 tokens at $0.50 instead of $5
Batch, prefix read from cache
- Cost
- $0.007
- Why
- everything halved again
| How it is sent | Cost | Why |
|---|---|---|
| Fast mode, uncached | $0.055 | 2× rates |
| US-only inference, uncached | $0.030 | 1.1× rates |
| Standard, uncached | $0.0275 | the sticker price |
| Standard, prefix read from cache | $0.014 | 3,000 tokens at $0.50 instead of $5 |
| Batch, prefix read from cache | $0.007 | everything halved again |
Source: CalculatorAI · calculatorai.app · drafts/claude-api-pricing-numbers.mjs
An eight-fold range on one model, one prompt and one answer. The AI Token Cost Calculator prices any request shape at these rates, with the cached share as an input; the AI Cost Calculator scales it to a month. Both read from the same price table, verified against Anthropic's page, so a change in the list price changes the answer without a change in the method. Whether the API is cheaper than a Claude subscription at all is a different question, answered in our Claude Pro vs Max vs API comparison.
Where these numbers come from
Every rate is from Anthropic's pricing page (platform.claude.com/docs/en/about-claude/pricing) as read on September 21, 2026: model prices per million tokens for base input, 5-minute and 1-hour cache writes, cache hits and output; the Batch API table; the note that Sonnet 5's introductory $2 / $10 has become its standard price; the 1.25× / 2× / 0.1× (0.025× on Claude Fable 5.1) cache multipliers; the tool-use system-prompt token counts per model; $10 per 1,000 web searches; the code-execution allowance; the 1.1× data-residency multiplier; and fast-mode pricing. The cache minimums per model are from Anthropic's prompt-caching documentation. The 30% tokenizer figure is Anthropic's own "approximately 30%" statement; the exact ratio varies with content. All worked examples are arithmetic in drafts/claude-api-pricing-numbers.mjs on the stated token counts — token counts are assumptions, not measurements, and the batch-plus-cache row assumes every request after the first reads the cache, which makes it a floor. The site's calculators use the same rates from src/config/ai-models.ts. Prices change; the method does not.
Frequently asked questions
How much does the Claude API cost per million tokens? As of September 2026: Claude Opus 5 is $5 input / $25 output, Claude Sonnet 5 $2 / $10, Claude Haiku 4.5 $1 / $5, and Claude Fable 5.1 $10 / $50. Cache reads are a tenth of the input price (a fortieth on Fable 5.1), cache writes 1.25× or 2×, and the Batch API halves input and output.
Is prompt caching worth it? Almost always, when a request has a fixed prefix of at least the model's minimum length. A 5-minute cache costs 1.25× to write and 0.1× to read, so it is cheaper than sending the prefix uncached from the second request on. A 1-hour cache breaks even on the third.
Why is the 1-hour cache more expensive? Its write costs 2× base input instead of 1.25×, because the entry is held longer. It pays off only when requests sharing the prefix arrive with gaps of more than five minutes; steady traffic keeps the cheaper 5-minute entry alive on its own, since every read refreshes the timer.
Does the Batch API discount stack with caching? Yes — Anthropic's pricing page says the multipliers stack. In the worked example, 200 questions over one 20,000-token document on Opus 5 cost $21.60 uncached in real time and $1.86 batched with the document read from cache, on the assumption that every request after the first hits the cache.
Is Claude Sonnet 5 cheaper than Sonnet 4.6?
Per token, yes: $2 / $10 against $3 / $15. On the same text, less than it looks: Sonnet 5 uses a tokenizer that produces about 30% more tokens, so an identical prompt costs roughly 13% less rather than 33%. Use the count_tokens endpoint to price your own prompts on each model.
