Pricing
Claude API pricing (November 2026)
Anthropic bills by the token, and each model has five prices: input, output, two cache-write tiers and the cache read. This post puts the current models' official prices side by side, explains how caching and long context are billed, and works through one Claude Code request. Prices are in US dollars, taken from Anthropic's pricing page and checked on November 2, 2026.
- Opus 5.5 costs $4 per million input tokens and $20 per million output tokens; Sonnet 5.5 $2 and $10; Fable 5.1 $10 and $50.
- A cache read is usually 0.1 times the input price, but 0.05 times on Opus 5.5 and Sonnet 5.5 and 0.025 times on Fable 5.1.
- Claude 4.6 and later models (except Haiku 5.5) bill the whole 1M context at the standard price. On Haiku 5.5, a prompt over 100,000 tokens puts the whole request on the higher tier.
- Claude 4.7 and later use a new tokenizer that produces about 30% more tokens for the same text. Count that when you compare old and new models.
Current models
Prices are US dollars per million tokens (MTok).
| Model | Input | 5-minute cache write | 1-hour cache write | Cache read | Output |
|---|---|---|---|---|---|
| Claude Fable 5.1 | $10 | $12.50 | $20 | $0.25 | $50 |
| Claude Opus 5.5 | $4 | $5 | $8 | $0.20 | $20 |
| Claude Sonnet 5.5 | $2 | $2.50 | $4 | $0.10 | $10 |
| Claude Haiku 5.5 (prompts up to 100,000 tokens) | $0.10 | $0.125 | $0.20 | $0.01 | $0.50 |
| Claude Haiku 5.5 (prompts over 100,000 tokens) | $0.50 | $0.625 | $1 | $0.05 | $2.50 |
Claude Mythos 5.1 costs the same as Fable 5.1 but is available only to organizations verified through Anthropic's verification programs.
Previous generation
| Model | Input | Cache read | Output |
|---|---|---|---|
| Claude Fable 5 | $10 | $1 | $50 |
| Claude Opus 5, Opus 4.8, 4.7, 4.6, 4.5 | $5 | $0.50 | $25 |
| Claude Sonnet 5 | $2 | $0.20 | $10 |
| Claude Sonnet 4.6, 4.5 | $3 | $0.30 | $15 |
| Claude Haiku 4.5 | $1 | $0.10 | $5 |
Sonnet 5 launched at an introductory $2 / $10 through August 31, 2026. That is now its standard price, and the increase to $3 / $15 planned for September 1 will not happen. Opus 5.5 is 20% cheaper than Opus 5 on both input and output.
How caching is billed
All three cache prices are multiples of the input price:
| Operation | Multiplier | Lifetime |
|---|---|---|
| 5-minute cache write | input × 1.25 | 5 minutes |
| 1-hour cache write | input × 2 | 1 hour |
| Cache read (hit) | input × 0.1; × 0.05 on Opus 5.5 and Sonnet 5.5; × 0.025 on Fable 5.1 | Same as the write; a read refreshes it |
Anthropic notes that a 5-minute cache pays for itself after one read and a 1-hour cache after two. The cache multipliers stack with the batch discount and data-residency pricing.
Batch: half price on input and output
The Batch API processes requests asynchronously at 50% of the standard input and output prices: $2 / $10 on Opus 5.5, $1 / $5 on Sonnet 5.5, $5 / $25 on Fable 5.1, and $0.05 / $0.25 on Haiku 5.5 up to 100,000 tokens. Claude Code's interactive requests do not go through the Batch API, so this discount applies only to offline jobs you write yourself.
Fast mode: faster Opus 5.5 output at twice the price
Fast mode gives Opus 5.5 significantly faster output at $8 input and $40 output, exactly twice the standard price. Cache multipliers and data residency stack on top of fast mode prices, and fast mode is not available with the Batch API. Fast mode for Opus 5 and Opus 4.8 is in research preview at $10 / $50.
Long context
- Claude 4.6 and later models, except Haiku 5.5, bill their full 1M-token context at standard prices: a 900k-token request costs the same per token as a 9k-token one.
- Haiku 5.5 is priced by prompt length, which counts cache reads and cache writes. A request over 100,000 tokens pays the higher prices for the whole request, even when part of it is a cache hit.
The new tokenizer: about 30% more tokens
Claude 4.7 and later models and Claude Mythos Preview use a newer tokenizer that produces about 30% more tokens for the same text, depending on the content. Sonnet 4.6 and earlier use the previous one. Moving from Sonnet 4.6 to Sonnet 5.5 cuts the input price from $3 to $2, but the same codebase becomes more tokens, so the real saving is smaller than the price change.
Pricing one Claude Code request
Claude Code resends the system prompt, tool definitions, files it has read and the conversation on every turn. Take one Sonnet 5.5 turn with 50,000 tokens of cached context, 2,000 tokens of new input and 1,000 tokens of output:
| Part | Cache hit | Cache miss |
|---|---|---|
| 50,000-token context | × $0.10 / MTok = $0.0050 | × $2 / MTok = $0.1000 |
| 2,000 tokens of new input | $0.0040 | $0.0040 |
| 1,000 output tokens | $0.0100 | $0.0100 |
| Total | $0.019 | $0.114 |
For simplicity the new input is priced as plain input. Claude Code actually writes it to the cache at 1.25 times, about $0.001 more on this turn, which does not change the result.
The same turn costs six times as much when the cache misses. Most tokens in a long session are resent context, so whether the cache keeps hitting matters more than a price difference of a few tenths. That is why caching comes first when choosing a relay; see Caching and billing and How to choose a relay.
Each model in detail
Specs, what changed from the previous generation, and how to select each model in Claude Code are in Claude Fable 5.1, Claude Opus 5.5 and Claude Sonnet 5.5.
How CoreCode prices it
CoreCode bills with the same five prices and multipliers as Anthropic, multiplied by a group ratio, and is topped up in yuan at ¥1 = $1 of credit. Each model's price and how far below the official price it is are on the pricing page, which syncs from the console every 10 minutes.
FAQ
Which is cheaper, Opus 5.5 or Sonnet 5.5?
Every Sonnet 5.5 token costs half as much as an Opus 5.5 token. Use Sonnet for everyday coding and Opus for hard reasoning and large changes; see Choosing a Claude model.
Why is my bill higher than the per-token prices suggest?
Three common reasons: the cache missed and context was resent at full price; the new tokenizer turns the same text into about 30% more tokens; and Claude Code's background tasks and subagents call other models. See Spending less.
Sources
- Anthropic: Pricing (model prices, cache multipliers, batch, long context, tokenizer; checked November 2, 2026)
- Anthropic: Prompt caching