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

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¹. 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

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¹. 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 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¹. 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¹.

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 shows the arithmetic, and prompt caching across providers 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¹. 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¹.

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¹. 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².

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.

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

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¹. 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¹.
• 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¹.
• Claude Managed Agents adds $0.08 per session-hour of running time to the tokens¹.

Three requests, worked through

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². 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 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.