Claude API pricing and token counts: a reference (November 2026)

This page collects the Claude API prices, multipliers and token measurements behind the practical checklist. All prices are Anthropic list prices in USD per million tokens (MTok), read on 2026-11-17, unless marked as OpenAI.
Model prices
| Model | Input | 5-min cache write | 1-hour cache write | Cache hit | Output | Batch input / output |
|---|---|---|---|---|---|---|
| Claude Opus 5.5 | $4 | $5 | $8 | $0.20 | $20 | $2 / $10 |
| Claude Sonnet 5.5 | $2 | $2.50 | $4 | $0.10 | $10 | $1 / $5 |
| Claude Haiku 5.5 (prompts up to 100k tokens) | $0.10 | $0.125 | $0.20 | $0.01 | $0.50 | $0.05 / $0.25 |
| Claude Haiku 5.5 (prompts over 100k tokens) | $0.50 | $0.625 | $1 | $0.05 | $2.50 | $0.25 / $1.25 |
Output costs 5 times as much as input for each model above. For comparison, Claude Opus 4.6 lists at $5 input and $25 output.
Modifiers that change the bill:
| Modifier | Effect |
|---|---|
| Haiku 5.5 over 100,000 tokens | The whole request pays the higher rates, cache reads included. Prompt length counts all input tokens, including cache reads and writes. |
US-only inference (inference_geo: "us") |
1.1x on all token categories for Claude 4.6 and later models |
| Fast mode on Opus 5.5 | $8 input, $40 output (double the standard rate); not available with the Batch API |
Prompt caching multipliers
| Cache operation | Multiplier | Duration |
|---|---|---|
| 5-minute cache write | 1.25x base input price | 5 minutes |
| 1-hour cache write | 2x base input price | 1 hour |
| Cache read (hit) | 0.1x base input price on most models | Same as the preceding write |
| Cache read on Opus 5.5 and Sonnet 5.5 | 0.05x base input price | Same as the preceding write |
Per Anthropic, caching pays off after one cache read with the 5-minute write, and after two reads with the 1-hour write. The multipliers stack with the Batch API discount and data residency pricing.
Minimum cacheable prompt length
| Minimum | Models |
|---|---|
| 512 tokens | Opus 5.5, Sonnet 5.5, Haiku 5.5 |
| 1,024 tokens | Sonnet 4.6 |
| 2,048 tokens | Opus 4.7 |
| 4,096 tokens | Opus 4.6, Opus 4.5, Haiku 4.5 |
Shorter prompts are processed without caching and no error is returned. If both cache_creation_input_tokens and cache_read_input_tokens are 0, nothing was cached.
Static tool overhead is a common caching target. Anthropic’s pricing page says the browser use toolset adds about 6,600 input tokens per request, and the computer use toolset about 4,500.
Batch API facts
| Item | Value |
|---|---|
| Price | “50 percent of the standard API prices,” input and output |
| Typical completion | Most batches finish within 1 hour |
| Expiry | A batch that has not completed within 24 hours expires |
| Caching inside batches | Discounts stack; cache hits are best effort, with typical hit rates of 30 to 98 percent |
| Suggested cache | 1-hour cache for shared context, since batches can run longer than 5 minutes |
| Fast mode | Not available with batch |
Tokenizer measurement: Claude 4.x versus 5.5
Anthropic states that Claude 4.7 and later models use a newer tokenizer that “produces approximately 30% more tokens for the same text,” with the exact increase depending on content.
Method: on 2026-11-17, four texts were sent to Anthropic’s messages/count_tokens endpoint for six models: claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5-20251001, claude-opus-5-5, claude-sonnet-5-5 and claude-haiku-5-5. The three 4.x models returned identical counts, and so did the three 5.5 models.
| Sample text | Characters | Claude 4.6 / Haiku 4.5 | Claude 5.5 models | Increase |
|---|---|---|---|---|
| English prose (one paragraph, repeated 3 times) | 1,752 | 344 | 503 | +46% |
| Python code | 3,432 | 1,458 | 1,603 | +10% |
| JSON payload | 3,568 | 1,547 | 1,851 | +20% |
| Turkish prose (one paragraph, repeated 3 times) | 1,629 | 710 | 851 | +20% |
Caveats: each count is one run and includes a small fixed message overhead. The samples are short and synthetic, so this is a spot check, not a benchmark. Only input tokens can be counted this way; output tokens are not covered.
Effect on input price, Opus 5.5 ($4) versus Opus 4.6 ($5), for the same text:
| Sample | Opus 5.5 cost per $5 of Opus 4.6 spend |
|---|---|
| Python code (+10%) | about $4.40 |
| JSON payload, Turkish prose (+20%) | about $4.79 |
| English prose (+46%) | about $5.85 |
Worked example: caching a static prefix
Hypothetical workload: a 20,000-token static prefix sent with 1,000 requests to Sonnet 5.5, each within 5 minutes of the previous one.
| Line | Calculation | Cost |
|---|---|---|
| Uncached | 20M tokens x $2/MTok | $40.00 |
| Cache write (once) | 20,000 x $2.50/MTok | $0.05 |
| Cache reads (999) | 19.98M x $0.10/MTok | $2.00 |
| Cached total | write + reads | about $2.05 |
The cached prefix costs about 95 percent less. The variable part of each prompt and all output tokens are unchanged.
Worked example: output share of cost
Hypothetical Sonnet 5.5 call with 3,000 input tokens and 800 output tokens.
| Part | Tokens | Share of tokens | Cost | Share of cost |
|---|---|---|---|---|
| Input | 3,000 | 79% | $0.006 | 43% |
| Output | 800 | 21% | $0.008 | 57% |
| Total | 3,800 | 100% | $0.014 | 100% |
Cutting output to 400 tokens saves about 29 percent of the request. Cutting input by 1,000 tokens saves about 14 percent.
When caching saves nothing
- Prefix used once: you pay 1.25x (or 2x) and get no read.
- Prefix below the minimum: silently not cached (see the table above).
- Early content changes: the cache matches an exact prefix in the order tools, system, messages. A timestamp or user ID near the top forces a new write every request.
- Sparse traffic: the 5-minute lifetime refreshes on each hit; a longer gap means a new write.
- Mid-stream edits: changing one level (tools, system, messages) invalidates that level and everything after it. Changing tool definitions invalidates the whole cache.
OpenAI, for comparison
OpenAI’s pricing page lists gpt-6.1-sol at $2 input and $10 output per million tokens, also a 5x ratio. On GPT-5.6 and later, OpenAI cache reads cost 0.1x uncached input (0.05x on GPT-6.1 Sol and Terra), and writes cost 1.25x for the 30-minute cache or 2.5x for the 12-hour cache. The minimum cacheable prefix is 1,024 tokens, and earlier OpenAI models have no cache-write charge. OpenAI’s Batch API also gives a 50 percent discount, with a 24-hour completion window.
Last verified: 2026-11-17 (prices and documentation), token counts measured 2026-11-17. Prices, discounts and model names change; check the linked pages before you rely on a number.
Sources
- Pricing, Anthropic (Claude Platform Docs), accessed 2026-11-17. https://platform.claude.com/docs/en/about-claude/pricing
- Prompt caching, Anthropic (Claude Platform Docs), accessed 2026-11-17. https://platform.claude.com/docs/en/build-with-claude/prompt-caching
- Message Batches API, Anthropic (Claude Platform Docs), accessed 2026-11-17. https://platform.claude.com/docs/en/build-with-claude/batch-processing
- Token counting, Anthropic (Claude Platform Docs), accessed 2026-11-17. https://platform.claude.com/docs/en/build-with-claude/token-counting
- Pricing, OpenAI (API docs, comparison provider), accessed 2026-11-17. https://developers.openai.com/api/docs/pricing
- Prompt caching, OpenAI (API docs, comparison provider), accessed 2026-11-17. https://developers.openai.com/api/docs/guides/prompt-caching
- Batch API, OpenAI (API docs, comparison provider), accessed 2026-11-17. https://developers.openai.com/api/docs/guides/batch