Claude API Pricing (2026): Per-Million-Token Rates for Every Model

Claude API pricing per million tokens

Sentra, the managed organization memory that gives every assistant and agent shared organizational context, publishes this guide so teams can size their Claude API spend before they buy. All figures are USD per million tokens (written MTok) and come from Anthropic's published pricing, cross-checked against claude.com/pricing on 19 October 2026. Rates as of October 2026, source: Anthropic pricing docs. Input and output are billed at different rates, and output is always the expensive half.

Cache reads are 0.1x the base input price on every model except Fable 5.1 and Mythos 5.1, where they are 0.025x ($0.25 per million), and Opus 5.5 and Sonnet 5.5, where they are 0.05x ($0.20 and $0.10 per million). Anthropic halved Sonnet 5.5's cache-read price from $0.20 to $0.10 when it launched Haiku 5.5. Retired models still reachable through Amazon Bedrock and Google Cloud carry their old rates: Claude Opus 4.1 and Opus 4 remain $15 in and $75 out, which is 3.75 times the Opus 5.5 price of $4 and $20 for a worse model, so check which model id your code actually pins. Claude Haiku 5.5, released on 7 October 2026 (Anthropic's Haiku 5.5 announcement), is now the cheapest current model, and Haiku 4.5 stays available at $1 and $5 for code that pins it.

Claude Haiku 5.5 pricing: the 100,000-token price step

Claude Haiku 5.5 is the one current model priced by prompt length. A request whose prompt is up to 100,000 tokens pays $0.10 per million input tokens and $0.50 per million output tokens. A request whose prompt is over 100,000 tokens pays $0.50 and $2.50 on all of its tokens, not only on the part above the line. Cache writes ($0.125 or $0.625 for 5 minutes, $0.20 or $1 for an hour) and cache reads ($0.01 or $0.05) step up the same way. The prompt length counts every input token in the request, including cache reads and cache writes, and each request is priced on its own, so a conversation that grows past 100,000 tokens pays the higher rate from that turn on while earlier turns keep the price they were billed at (Anthropic pricing docs).

Work an example. A request with 80,000 input tokens and 2,000 output tokens costs (0.08 × $0.10) + (0.002 × $0.50) = $0.009. Add 40,000 tokens of context and the same request, now 120,000 input tokens, costs (0.12 × $0.50) + (0.002 × $2.50) = $0.065, about 7.2 times as much for 50% more input. On Haiku 4.5 that 120,000-token request costs (0.12 × $1) + (0.002 × $5) = $0.13, so Haiku 5.5 is half the Haiku 4.5 price above the line and a tenth of it below. Anthropic puts the average saving against Haiku 4.5 at around 75%, noting that 90% of Haiku 4.5 requests fell under 100,000 tokens and that Haiku 5.5's updated tokenizer uses slightly more tokens per task (Anthropic's Haiku 5.5 announcement). If you route long-context work to Haiku 5.5, keep prompts under 100,000 tokens where you can, because that line sets the rate. US-only inference adds its 1.1x multiplier on both sides of it.

Batch API pricing: half price for asynchronous work

The Batch API applies a flat 50% discount to both input and output for requests you do not need answered immediately. Anything on a schedule rather than in a user's face belongs here: nightly enrichment, backfills, evaluation runs, bulk classification.

Batch discounts stack with prompt caching and with US-only pricing, but fast mode is not available through the Batch API, and Claude Managed Agents sessions get no batch discount because they are interactive. Rates per million tokens, as of October 2026, from Anthropic's pricing docs.

What prompt caching actually saves

Prompt caching charges a premium to write context into the cache and then a steep discount to read it back. A 5-minute cache write costs 1.25x the base input rate, a 1-hour write costs 2x, and a read costs 0.1x (0.05x on Opus 5.5 and Sonnet 5.5, 0.025x on Fable 5.1). That arithmetic gives a clean break-even: the 5-minute cache pays for itself after a single read, and the 1-hour cache pays for itself after two.

So caching is close to free money for an agent that re-reads the same system prompt and the same repository context across a session, and it is a pure loss for one-shot calls that never read the cache back. The multipliers also stack with the Batch discount and with data-residency pricing.

Three mechanics decide whether the discount actually lands, according to Anthropic's prompt caching docs. First, the cache lifetime is measured from the start of the request that writes or reads the entry, so a response that streams for four minutes leaves about one minute for the next request to hit a 5-minute cache; each hit refreshes the lifetime at no extra charge. Second, prompts below a minimum length are silently not cached: 512 tokens on Fable 5.1, Opus 5.5, Opus 5, Sonnet 5.5 and Haiku 5.5, 1,024 on Sonnet 5 and Opus 4.8, and 4,096 on Haiku 4.5. Third, a cache entry only becomes available once the first response begins, so parallel requests fired at the same moment all pay the write price. If both cache_creation_input_tokens and cache_read_input_tokens come back as 0 in the usage block, the prompt was not cached.

The tokenizer change that makes a rate cut into a price rise

This is the single most under-reported line in Claude API pricing. Models from Claude 4.7 onward use a newer tokenizer that produces roughly 30% more tokens for the same text than the tokenizer used by Sonnet 4.6 and earlier. Rates are charged per token, so identical prompts on a newer model bill for more tokens.

Work an example. Sonnet 4.6 costs $3 per million input tokens; Sonnet 5 costs $2, a 33% cut on paper. Feed both the same 100,000-character prompt and the older model might count 25,000 tokens at $3, which is $0.075, while the newer one counts about 32,500 tokens at $2, which is $0.065. Still cheaper, but 13% cheaper rather than 33%. Move from Sonnet 4.6 to Opus 5 and the same 30% inflation lands on top of a rate increase. Always price a migration on measured token counts from the token counting endpoint, never on the headline rate.

Where the API bill really comes from

Teams reach for a cheaper model when the invoice grows, and that is usually the wrong lever. Two things dominate a real agent bill, and neither is the per-token rate.

• Output is 5x input on every current model. Opus 5.5 costs $4 in and $20 out. A verbose agent that narrates its reasoning burns the expensive side of the meter, so response-length discipline beats model downgrades.
• Input volume compounds with conversation length. Every turn resends the whole history, so token spend on a long agent session grows quadratically rather than linearly. This is the mechanism behind most surprise bills.
• Retrieval pads the prompt. A RAG pipeline that pastes ten full documents into context to answer one question pays for all ten, every turn, whether or not they were relevant.
• Retired model ids quietly cost almost four times as much. Opus 4.1 at $15 in and $75 out is still callable on Amazon Bedrock and Google Cloud and still billed at the old rate, against $4 and $20 for Opus 5.5.

The third item is the one a managed organization memory addresses. Sentra compiles the answer to a question into a handful of governed, current facts with their provenance, so an agent receives the two sentences that settle the matter instead of the six documents that mention it. Cutting input tokens at the source compounds with prompt caching rather than competing with it, and it removes the stale answers a vector search returns when an old document still matches the query. In Sentra's internal Terminal-Bench 2.1 evaluation, which is pending official verification, Codex CLI running GPT-5.5 at xhigh effort with Sentra Code Memory used 41.2% fewer tokens and 72.6% less model spend ($510.30 against $1,862.98) across 445 trials, while scoring 88.31% mean reward against an 83.37% published baseline (results). That run used an OpenAI model, so read it as evidence for the mechanism rather than as a Claude price quote.

API rates or a subscription: the break-even

Claude Code ships inside the paid Claude subscriptions, so the honest question for most developers is which billing model is cheaper at their volume. Take a Pro plan at $20 a month (or $17 a month billed annually) and assume a normal coding mix of roughly 80% input and 20% output tokens by count.

Read that as a threshold, not a recommendation. If your Opus 5.5 usage runs past roughly 126,000 tokens on a working day (about 100,000 on legacy Opus 5), the $20 subscription is already the cheaper route, provided your work fits inside Pro's usage limits; below it, API billing wins and you only pay for what you use. Add prompt caching and the API side stretches further: assume 70% of input tokens become cache reads and Sonnet 5.5's blended rate falls to about $2.54 per million, pushing the break-even out to roughly 7.9M tokens a month. Both figures assume 22 working days and no Batch discount.

Costs that sit outside the token meter

• Web search runs $10 per 1,000 searches on top of the tokens the results consume.
• Web fetch adds no charge beyond the tokens of whatever it pulls into context.
• Code execution is free when the same request includes web search or web fetch. Used on its own, it gives every organization 1,550 free container-hours a month (claude.com/pricing states this as 50 free hours a day), then bills $0.05 per hour per container, with a 5-minute minimum per execution.
• Claude Managed Agents add $0.08 per session-hour, metered only while a session is actually running.
• Pinning inference to the US with inference_geo applies a 1.1x multiplier to every token category on Claude 4.6 and later.
• Amazon Bedrock and Google Cloud set their own regional pricing for Claude, so a deployment there can differ from Anthropic's list price; check the cloud provider's pricing page for your region.
• Tool definitions are input tokens. Declaring the computer-use toolset alone adds about 4,500 tokens to every request that carries it.

What do Claude Opus 5.5 fast mode and US-only inference cost?

Fast mode on Claude Opus 5.5 costs $8 per million input tokens and $40 per million output tokens, exactly 2x the standard rate, and US-only inference adds a 1.1x multiplier to every token category on Claude 4.6 and later models. Anthropic says fast mode delivers up to 2.5x faster output on Opus 5.5 (claude.com/pricing). It is available on the first-party Claude API and, for Opus 5.5, on Claude in Microsoft Foundry deployments hosted on Azure; it is not offered on Claude Platform on AWS, Amazon Bedrock, Google Cloud or the Batch API, and on Opus 5 and Opus 4.8 it is still a research preview, according to Anthropic's pricing docs. US-only inference is set with the inference_geo parameter, and the 1.1x applies to input, output, cache writes and cache reads alike (data residency docs).

The multipliers compound. One million input tokens plus one million output tokens on Opus 5.5 cost $4 + $20 = $24 at standard global rates. The same traffic in fast mode costs $8 + $40 = $48, and with US-only inference on top it costs $48 × 1.1 = $52.80, which is 2.2 times the standard bill. Prompt caching multipliers still apply on top of fast mode, so a cached prefix read in fast mode costs 0.05 × $8 = $0.40 per million tokens on Opus 5.5. Fast mode is not available on Opus 4.7, and on Opus 4.6 a fast request runs at standard speed and standard price.

Use fast mode when a person is waiting on the output and the 2x premium is smaller than the cost of their time; leave it off for background agents and anything that could go through the Batch API. Use US-only inference when a contract or regulator requires US processing, and leave global routing on otherwise.

Why did my Claude API bill go up after switching to a newer model?

A newer Claude model with a lower headline rate can still produce a higher bill, because the bill is rate multiplied by tokens and several settings change the token count or the multiplier. These are the five causes worth checking, in the order they usually matter.

• The tokenizer changed. Claude 4.7 and later models produce approximately 30% more tokens for the same text than Sonnet 4.6 and earlier, according to Anthropic's pricing docs, so a migration from Sonnet 4.6 can turn a one-third rate cut into a saving of about 13%.
• Fast mode was switched on. Fast mode bills Opus 5.5 at $8 in and $40 out, twice the standard $4 and $20, and Opus 5 and Opus 4.8 at $10 and $50.
• US-only inference was pinned. Setting inference_geo to us multiplies every token category by 1.1 on Claude 4.6 and later, including cache reads and writes.
• The cache tier or hit rate changed. A 1-hour cache write costs 2x the base input rate against 1.25x for a 5-minute write, so it only pays off after two reads, and a prompt that changes on every request never gets a cache hit at all.
• Tools and output grew. The tool-use system prompt alone adds 286 input tokens per request on Opus 5.5, Sonnet 5.5 and Haiku 5.5, the computer-use toolset adds about 4,500, and output costs 5x input, so a chattier agent costs more even at a lower rate.

Run the same prompts through the token counting endpoint on the old and new model, compare the usage block of real responses for cache reads, cache writes and output tokens, and budget from those measured counts rather than from the headline rate.

How do you calculate the cost of a Claude API workload?

Multiply each token category by its per-million rate and add the results: uncached input, cache writes, cache reads and output are billed separately, then any batch, fast mode or US-only multiplier is applied. These three worked examples use the October 2026 rates from Anthropic's pricing docs.

• Cached agent session on Sonnet 5.5: ten calls share a 100,000-token prompt and each returns 2,000 output tokens. The first call writes the cache for 0.1M × $2.50 = $0.25, the next nine read it for 9 × 0.1M × $0.10 = $0.09 because Sonnet 5.5 reads at 0.05x, and output costs 0.02M × $10 = $0.20, so the total is $0.54. Without caching the input alone costs 1M × $2 = $2.00 and the total is $2.20, about 4.1 times more.
• The same session on Opus 5.5: the write costs 0.1M × $5 = $0.50, nine reads cost 0.9M × $0.20 = $0.18 because Opus 5.5 reads at 0.05x, and output costs 0.02M × $20 = $0.40, for $1.08 in total against $4.40 uncached.
• Nightly batch job on Haiku 5.5: 2,000 documents at 3,000 input tokens and 500 output tokens each is 6M input and 1M output tokens, and every request sits far below the 100,000-token line. Through the Batch API that costs 6 × $0.05 + 1 × $0.25 = $0.55, against 6 × $0.10 + 1 × $0.50 = $1.10 at standard rates and 6 × $0.50 + 1 × $2.50 = $5.50 for the same batch on Haiku 4.5.

If your workload needs US-only inference, multiply every one of these totals by 1.1. The caching examples only hold if the prompt prefix is byte-identical between calls and each call lands inside the cache lifetime, so check cache_read_input_tokens in real responses before you budget on them.

Frequently Asked Questions