# Claude API pricing in 2026: Fable, Opus, Sonnet and Haiku

URL: https://infro.io/blog/claude-api-pricing-2026
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-10-20
Last modified: 2026-10-20
Last reviewed: 2026-10-20 (next review due 2026-11-19)
Topic: Cost and FinOps
Format: Guide

> Claude API rates per million tokens in October 2026: Fable 5.1 $10 input and $50 output, Opus 5.5 $4 and $20, Sonnet 5.5 $2 and $10, Haiku 5.5 $0.10 and $0.50 for prompts up to 100,000 tokens and $0.50 and $2.50 above. Cache reads cost 0.025x to 0.1x of input depending on the model, 5-minute cache writes 1.25x and 1-hour writes 2x. Batch is half price, US-only inference is 1.1x, and Claude 4.7 and later models count about 30% more tokens for the same text.

Key takeaways:
- Opus 5.5 is $4 input and $20 output per 1M tokens, Sonnet 5.5 $2 and $10, Haiku 5.5 $0.10 and $0.50 up to 100,000 prompt tokens, Fable 5.1 $10 and $50.
- Cache reads are 0.1x input on most models, 0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.1; 5-minute writes are 1.25x and 1-hour writes 2x.
- Haiku 5.5 re-prices the whole request when the prompt, cache reads included, passes 100,000 tokens.
- Claude 4.7 and later count about 30% more tokens for the same text, so compare cost per task, not rate per token, when you migrate.
- Batch halves both input and output; US-only inference multiplies everything by 1.1; Fast mode on Opus 5.5 is $8 and $40.

**How much does the Claude API cost?** In October 2026, per million tokens: Claude Fable 5.1 is $10 input and $50 output, Opus 5.5 is $4 and $20, Sonnet 5.5 is $2 and $10, and Haiku 5.5 is $0.10 and $0.50 for prompts up to 100,000 tokens[1]. Cached prompt reads cost a fraction of input, Batch halves everything, and US-only inference adds 10%.

Two details on Anthropic's current rate card change real bills more than the headline numbers do: cache-read multipliers now differ by model, and the tokenizer used since Claude Opus 4.7 produces more tokens for the same text. Both are covered below, with worked examples.

## Current Claude models and rates

| Model | Input | 5m cache write | 1h cache write | Cache read | Output |
| --- | --- | --- | --- | --- | --- |
| Claude Fable 5.1 | $10.00 | $12.50 | $20.00 | $0.25 | $50.00 |
| Claude Opus 5.5 | $4.00 | $5.00 | $8.00 | $0.20 | $20.00 |
| Claude Opus 5 | $5.00 | $6.25 | $10.00 | $0.50 | $25.00 |
| Claude Sonnet 5.5 | $2.00 | $2.50 | $4.00 | $0.10 | $10.00 |
| Claude Sonnet 5 | $2.00 | $2.50 | $4.00 | $0.20 | $10.00 |
| Claude Sonnet 4.6 | $3.00 | $3.75 | $6.00 | $0.30 | $15.00 |
| Claude Haiku 5.5 (prompt up to 100K) | $0.10 | $0.125 | $0.20 | $0.01 | $0.50 |
| Claude Haiku 5.5 (prompt over 100K) | $0.50 | $0.625 | $1.00 | $0.05 | $2.50 |
| Claude Haiku 4.5 | $1.00 | $1.25 | $2.00 | $0.10 | $5.00 |

Table: Claude API rates per 1M tokens, from Anthropic's pricing page on 2026-10-20.

Anthropic also notes that the $2 and $10 rate on Sonnet 5, announced as introductory, is now its standard price; the increase scheduled for 1 September 2026 did not happen[1]. Older models such as Opus 4.1 and Sonnet 4 are retired on the Claude API but may still be served on Bedrock or Google Cloud at their old rates. [The Claude lineup compared](https://infro.io/blog/anthropic-model-lineup-2026) covers which model to use for what.

## Prompt caching: the multipliers now differ by model

Anthropic prices caching as multipliers on the input rate: a 5-minute cache write is 1.25x, a 1-hour write is 2x, and a cache read is 0.1x on most models, **0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.1**[1]. Its own break-even statement for the standard multiplier: a 5-minute write pays for itself after one read, a 1-hour write after two.

On the newest models the read is so inexpensive that caching changes the economics of agents and long conversations. A 40,000-token prefix read from cache on Sonnet 5.5 costs $0.004 instead of $0.08. The multipliers also stack with the Batch discount and with data residency pricing[1].

Two traps:

- **Writing caches nobody reads.** Every write costs 25% or 100% more than sending the same tokens uncached. A prefix that changes per request should not carry a breakpoint.
- **Reading the usage fields wrongly.** Claude reports `input_tokens` (tokens after the last breakpoint), `cache_creation_input_tokens` and `cache_read_input_tokens` side by side; the prompt is the sum of all three. [Tokens are not the billing unit](https://infro.io/blog/tokens-are-not-the-billing-unit) shows the arithmetic, and [prompt caching across providers](https://infro.io/blog/prompt-caching-break-even) compares break-even points.

## The Haiku 5.5 prompt-length tier

Haiku 5.5 is priced by prompt length. A request whose prompt is over 100,000 tokens pays the higher rates on the whole request, and the prompt length **includes cache reads and cache writes**, so a large cached prefix can push a request over the line even if few new tokens are sent[1]. Every other Claude 4.6-and-later model includes the full 1M-token context at standard rates; a 900K-token request pays the same per-token rate as a 9K-token request[1].

## The tokenizer change

Anthropic states that Claude 4.7 and later models, and the Fable and Mythos families, use a newer tokenizer that produces **approximately 30% more tokens for the same text**; Sonnet 4.6 and earlier use the previous one[1]. Its token counting page adds the practical rule: do not reuse counts measured on an older model to estimate cost; count your prompts again with the model ID you plan to use[2].

This matters for every migration estimate. Moving from Sonnet 4.6 to Sonnet 5.5 cuts the per-token rate by a third, but if the same prompts produce 30% more tokens, the cost per request falls by roughly 13%, not 33%. The exact change depends on your content, which is why the count-twice method is worth the ten minutes.

```python
import anthropic

client = anthropic.Anthropic()
request = {
    "system": open("system_prompt.txt").read(),
    "messages": [{"role": "user", "content": open("sample_ticket.txt").read()}],
}

# Token counting is free and uses the tokenizer of the model you name.
old = client.messages.count_tokens(model="claude-sonnet-4-6", **request).input_tokens
new = client.messages.count_tokens(model="claude-sonnet-5-5", **request).input_tokens
print(f"{old} -> {new} tokens ({new / old - 1:+.0%})")
```

## Modifiers that stack

| Modifier | Effect | Notes |
| --- | --- | --- |
| Batch API | Half the input and output rate | Opus 5.5 on Batch is $2 and $10; not available with Fast mode |
| Fast mode | Opus 5.5 at $8 input and $40 output | Claude API and Azure-hosted Foundry deployments only |
| US-only inference | 1.1x on every token category | Claude 4.6 and later, via `inference_geo: "us"` |
| Cloud regional endpoints | 10% premium over global | Set by Bedrock and Google Cloud, not the Claude API |

Table: Pricing modifiers on Anthropic's pricing page, 2026-10-20.

## Costs beyond tokens

- **Tool definitions add input.** Whenever tools are present, Anthropic adds a tool-use system prompt: 286 tokens on Opus 5.5, Sonnet 5.5 and Haiku 5.5 with `tool_choice` auto. The bash tool adds 325 tokens and the text editor tool 974 on Claude 4.7 and later[1]. An agent with dozens of MCP tools pays for every definition on every turn unless they are deferred or cached.
- **Web search** is $10 per 1,000 searches plus the tokens of the results. **Web fetch** has no fee beyond tokens; a 10 kB page is roughly 2,500 tokens[1].
- **Code execution** is free when used with web search or web fetch, and otherwise billed by container time after 1,550 free hours a month[1].
- **Claude Managed Agents** adds $0.08 per session-hour of running time to the tokens[1].

## Three requests, worked through

> **Example: A coding-agent turn on Sonnet 5.5**
> A 40,000-token prefix (system prompt, tools, repository context) read from cache, 2,000 new input tokens, 1,500 output tokens.
> 
> - Cache read: 40,000 × $0.10 / 1M = $0.004
> - Fresh input: 2,000 × $2.00 / 1M = $0.004
> - Output: 1,500 × $10.00 / 1M = $0.015
> - **Total: $0.023.** Without the cache the input alone would be $0.084, for $0.099 in total.

> **Example: The Haiku 5.5 line**
> A summarisation request with 500 output tokens.
> 
> - Prompt of 95,000 tokens: 0.095M × $0.10 + 0.0005M × $0.50 = about $0.0098
> - Prompt of 105,000 tokens: 0.105M × $0.50 + 0.0005M × $2.50 = about $0.0538
> 
> Ten thousand more prompt tokens make the request about five and a half times as expensive. Trimming retrieved context to stay under 100,000 is worth an engineering hour on any high-volume Haiku path.

> **Example: A batch of contract reviews on Opus 5.5**
> 1,000 documents, each 20,000 input tokens and 2,000 output tokens.
> 
> - Standard: 20M × $4 + 2M × $20 = $120
> - Batch: $60
> - Batch with US-only inference: $66

## Estimating before you send

Anthropic's `POST /v1/messages/count_tokens` takes the same body as a message request, including system prompt, tools, images and PDFs, and returns `input_tokens`. It is free, has its own rate limits (5,000 to 20,000 requests a minute by tier), and its result is an estimate that can differ by a small amount from what is billed[2]. It refuses server tools such as web search and URL-sourced images, so send images as base64 to count them. Multiply the count by the input rate, add your `max_tokens` times the output rate as the worst case, and you have an upper bound. [Count tokens before you call the API](https://infro.io/blog/count-tokens-before-api-call) compares this endpoint with OpenAI's and Google's.

## Pricing Claude requests with INFRO

You connect your own Anthropic account (or Claude on Google Cloud's Vertex AI) and Anthropic bills you directly; INFRO adds no margin to it. Each request INFRO serves is recorded with Anthropic's own token counts, cache reads and writes included, and an estimated cost at the list rate or, from the Team plan, your negotiated rate. Claude Code and the Claude Agent SDK can route through INFRO's `/v1/messages` endpoint with only the base URL and key changed, so a coding agent's spend is capped per key before Anthropic is called. On the Business plan the month's estimate is checked against Anthropic's own cost API.

## Summary

Pick the model by task and read its row, not the family's. Cache long, stable prefixes on Opus 5.5, Sonnet 5.5 and Fable 5.1, where reads are very inexpensive; keep Haiku 5.5 prompts under 100,000 tokens; move anything nobody is waiting for to Batch; and when you migrate from a pre-4.7 model, count your real prompts on both tokenizers before you promise anyone a number.

## Questions

### How much does Claude Opus 5.5 cost?

$4 per million input tokens and $20 per million output tokens on the Claude API, with cache reads at $0.20 per million, 5-minute cache writes at $5 and 1-hour writes at $8. On the Batch API it is $2 input and $10 output. Fast mode costs $8 input and $40 output.

### Does Claude Sonnet 5.5 cost less than Sonnet 4.6?

Per token, yes: $2 and $10 against $3 and $15. Per task the gap is smaller, because Claude 4.7 and later models use a tokenizer that produces about 30% more tokens for the same text. Count your own prompts on both models before you estimate the change.

### Does Claude charge for 1M token context?

Claude 4.6 and later models, except Haiku 5.5, include the full 1M-token context window at standard rates; a 900K-token request pays the same per-token rate as a 9K-token one. Haiku 5.5 charges higher rates for prompts over 100,000 tokens.

### Is Claude's token counting endpoint free?

Yes. Anthropic says token counting is free to use, with its own requests-per-minute limits by usage tier, separate from message creation. The count is an estimate and can differ slightly from the tokens billed.

## Sources

1. Pricing — Anthropic. https://platform.claude.com/docs/en/about-claude/pricing (accessed 2026-10-20)
2. Token counting — Anthropic. https://platform.claude.com/docs/en/build-with-claude/token-counting (accessed 2026-10-20)