Claude Opus 5.5 Pricing: Fast Mode, Caching & Batch Costs

Short version: Claude Opus 5.5 costs $4 per million input tokens and $20 per million output tokens on the Claude API. Fast mode doubles that to $8 and $40 for up to 2.5x faster output, the Batch API halves it to $2 and $10, and cache reads drop to $0.20 per million, just 5% of the input rate. US-only inference adds 10% to every token price. If you only want Opus 5.5 in the Claude app, the cheapest plan that includes it is Pro at $20 a month ($17 a month billed annually).

Those headline numbers are the easy part. What actually decides an Opus 5.5 bill is how the levers combine: thinking tokens billed as output, cache writes that cost more than plain input, a fast mode that throws away your cache when you switch it on, and a Batch discount that stacks with caching but not with fast mode. If you want the model itself first, read our Claude Opus 5.5 guide to what's new, specs and breaking changes, then come back here for the money side.

Sources: Anthropic's Claude pricing documentation, its October 7, 2026 rate card, the Opus 5.5, fast mode, caching, batch and thinking docs, and the claude.com pricing page, all checked on October 26, 2026. We haven't run billed Opus 5.5 workloads ourselves, so every cost example is our own arithmetic from published rates.

Claude Opus 5.5 Pricing at a Glance

Every published Opus 5.5 rate on the Claude API, in US dollars per million tokens (MTok):

*Our arithmetic: Anthropic says prompt caching multipliers (1.25x, 2x and 0.05x on Opus 5.5) "apply on top of fast mode pricing" but doesn't print the resulting numbers.

Three things in that table matter more than they look:

• The cache read discount is unusually deep. Most Claude models read cache at 10% of the input price; on Opus 5.5 (and Sonnet 5.5) a hit costs 5%.
• There is no long-context surcharge. The full 1M-token context window is billed at the same per-token rate whether a request is 9K or 900K tokens, and fast mode pricing also stays flat across the whole window.
• Fast mode and Batch never mix. Fast mode is not available on the Batch API, so there is no "fast batch" row to budget for.

What You're Actually Billed For on Opus 5.5

An Opus 5.5 request is billed in four buckets, each reported in the response's usage object: uncached input (input_tokens), cache writes at 1.25x or 2x input (cache_creation_input_tokens), cache reads at 0.05x (cache_read_input_tokens) and output, including reasoning you may never see (output_tokens).

Thinking is the line item people underestimate. Anthropic's docs say thinking tokens are "billed as output tokens", in full, even when the display is summarized or omitted, and earlier thinking blocks left in context are billed again as input. Opus 5.5 can't turn thinking off, so your main control is effort, which defaults to medium. Our guide on how to choose thinking level and effort for real workloads walks through picking the lowest level that still passes your quality bar.

Tools add hidden input too: a 286-token tool-use system prompt on Opus 5.5 whenever any tool is present, plus every tool's name, description and schema. The bash tool adds 325 tokens, the text editor 974 and the computer use toolset about 4,500 per request, exactly the kind of stable prefix you want cached.

Once you know the buckets, there are four main ways to change what each one costs: run at standard speed, pay extra for fast mode, cache the repeated part of your prompt, or move work that can wait to the Batch API.

Data residency is a fifth, smaller modifier that multiplies everything by 1.1x. We cover it with the other add-on costs further down.

Fast Mode: 2x the Price for Up to 2.5x the Speed

Fast mode runs the same Opus 5.5 model on a faster inference configuration, with "no change to intelligence or capabilities" according to Anthropic. You opt in per request with speed: "fast"; on Opus 5.5 it needs no beta header or access request in the Start, Build and Scale usage tiers.

The price is exactly double: $8 per million input tokens and $40 per million output tokens, flat across the full context window. For comparison, fast mode on Opus 5 and Opus 4.8, still in research preview, costs $10 and $50. So Opus 5.5 fast mode is cheaper than older fast mode, and 60% above Opus 5 at standard speed ($5/$25).

What you get for the money is narrower than "2x faster":

• The speed-up is in output tokens per second, not time to first token. Anthropic quotes "up to 2.5x higher output tokens per second". A long reasoning-heavy answer benefits a lot; a short reply where most of the wait is before the first token benefits much less.
• It has its own rate limit. Exceeding it returns a 429; the usage.speed field shows which speed actually ran.
• It's not on every platform. For Opus 5.5, Anthropic lists fast mode on the Claude API (including Claude Managed Agents), on Claude Models on Google Cloud (Anthropic managed) and on Microsoft Foundry deployments hosted on Azure. It is not offered with the Batch API or with a Priority Tier commitment.

The hidden cost: switching speeds breaks your cache

This is the part that surprises people. Anthropic's caching docs list the speed setting as a change that invalidates the system and message caches, and the fast mode docs add that "requests at different speeds do not share cached prefixes". The Claude Code guide spells out the consequence: the first time you enable fast mode in a conversation, you pay the full fast mode uncached input price for the entire conversation context.

Our arithmetic: flip a 150,000-token conversation into fast mode and that one call costs about $1.20 in input alone (150K × $8 per million), versus $0.03 as a standard-speed cache read. Flip back and you rebuild the standard cache too. Decide on fast mode at the start of a session, and expect a cache miss whenever a rate limit forces a fallback to standard speed.

Fast mode inside Claude subscriptions

In Claude Code you toggle fast mode with /fast. On Pro, Max, Team and Enterprise plans it needs usage credits turned on, and the Claude Code docs say fast mode "draws directly from usage credits, even if you have remaining usage on your plan". So fast mode is never covered by your subscription allowance. Our breakdown of Claude Code API pricing and usage costs shows how that fits the rest of a Claude Code bill.

Prompt Caching on Opus 5.5: Write Tiers, Read Discount and Break-Even

Prompt caching moves an Opus 5.5 bill more than any other lever, because agents resend the same system prompt, tools and growing history every turn. Instead of paying $4 per million for that prefix each time, you pay once to write it and then $0.20 per million to read it back.

There are two write tiers and one read price:

The billing flow is the same every time: the first call pays the write premium, every later call within the lifetime reads at 5%, and the savings show up on the bill from the first hit onward.

Break-even math: when caching pays off

Anthropic's general rule is that the 5-minute cache pays off after one read and the 1-hour cache after two. Because Opus 5.5 reads cost 5% instead of 10%, the numbers are even friendlier. Here is our arithmetic for a 100,000-token prefix sent repeatedly:

So the 5-minute cache is already 35% cheaper on the second call, and the 1-hour cache is 2 cents more expensive after one read but clearly ahead from the second read onward. If a prefix is used only once, caching it costs you 25% (5-minute) or 100% (1-hour) extra on that slice.

If a prefix is reused more often than every five minutes, stay on the 5-minute cache: each hit refreshes it free. Use the 1-hour cache when calls are spaced between five minutes and an hour apart, like a user returning to a chat or a long-running sub-agent. Note that the lifetime counts from the start of the request, so a four-minute streamed response leaves about a minute for the follow-up to hit a 5-minute entry.

The rules that quietly cost money

• 512-token minimum. Prompts shorter than 512 tokens on Opus 5.5 simply aren't cached, and no error is returned. If both cache usage fields come back as 0, that's usually why.
• Changing the prefix means rewriting it. Editing tool definitions invalidates the whole cache; toggling web search or citations, or switching speed, invalidates the system and message caches; changing effort or images invalidates message blocks. Opus 5.5 does let you add a system instruction mid-conversation as a role: "system" message without breaking the cache.
• Breakpoints must sit on stable content. A timestamp inside the cached block means a fresh write on every request and never a read.

Bonus: Anthropic notes cache hits aren't deducted against your rate limit. For breakpoints and agent prompt layout in depth, see Claude prompt caching explained.

Batch API: Half Price, and How It Stacks With Caching

The Message Batches API takes up to 100,000 requests (or 256 MB) per batch and charges 50% of standard prices on input and output: $2 and $10 per million for Opus 5.5. Most batches finish in under an hour; unfinished ones expire after 24 hours, and errored, canceled or expired requests aren't billed.

The Batch discount stacks with prompt caching, and Anthropic's rate card prints the combined numbers: $2.50 per million for 5-minute cache writes, $4 for 1-hour writes and $0.10 for cache reads on Batch. The catch: batch requests run concurrently and in any order, so cache hits are "best-effort". Anthropic recommends identical cache_control blocks in every request and the 1-hour TTL.

You can't set speed: "fast" inside a batch. With the output-300k-2026-03-24 beta header, Opus 5.5 can write up to 300,000 output tokens per Batch request (128K normally) at standard Batch prices, which is still $3 per maxed-out request. Good Batch candidates: nightly code review, eval runs, classification, extraction and bulk summaries.

US-Only Inference, Tools and Other Costs Beyond Tokens

A few modifiers and fees sit outside the core token table.

US-only inference (1.1x). Setting inference_geo: "us" on Claude 4.6 and later models multiplies every token category by 1.1, including cache writes and reads: $4.40 / $22 standard, $0.22 cache reads, and $2.20 / $11 on Batch. The default global routing uses standard prices. It also stacks on fast mode, which by our arithmetic makes US-only fast mode $8.80 / $44. The parameter works on the Claude API, Claude Platform on AWS and Claude Models on Google Cloud (Anthropic managed); on Microsoft Foundry the equivalent is the US Data Zone Standard deployment type at the same 1.1x.

Server tools. Web search costs $10 per 1,000 searches plus result tokens, which stay in context on later turns. Web fetch only costs the tokens fetched (about 2,500 for an average page, per Anthropic). Code execution is free alongside the current web search or fetch tools; otherwise 1,550 free container-hours a month, then $0.05 per hour.

If your agent reads a lot of web pages, cleaning them before they reach the model is a cheap win: a scraping API that returns clean markdown keeps navigation and boilerplate out of your $4-per-million input.

Managed Agents. Sessions pay normal token rates plus $0.08 per running session-hour, with no Batch discount. Every tool and MCP server you attach also adds definition tokens, worth weighing when you choose between Claude skills, MCP tools and subagents.

The tokenizer. Opus 5.5 uses the newer tokenizer introduced with Claude 4.7, which produces about 30% more tokens for the same text than Sonnet 4.6 and earlier. If you're migrating from an older model, count tokens on real prompts before comparing per-million prices.

Worked Examples: What Opus 5.5 Really Costs per Task

These are our own calculations from Anthropic's list prices, not measured bills. Real token counts depend on your prompts, effort level and how much the model thinks.

Example 1: one big request

A single call with 200,000 input tokens (a large codebase slice or a long contract) and 20,000 output tokens, including thinking, with no caching:

For comparison, the same call costs $1.50 on Opus 5 and $0.60 on Gemini 4 Argon at its intro rates, rising to $1.20 from December 1 (details in our Gemini 4 Argon pricing breakdown).

Example 2: a 40-turn coding agent session

An agent loop of 40 requests. Each request carries about 80,000 input tokens (system prompt, tools, repo context and history). Turn 1 writes all 80K to the 5-minute cache; every later turn reads 75K from cache and writes 5K of new history. Each turn produces 2,000 output tokens.

Two lessons jump out. Caching cuts the Opus 5.5 session by about 75%, which dwarfs the choice between models. And because its cache reads are 60% cheaper, cached Opus 5.5 costs about 31% less than cached Opus 5, even though headline prices are only 20% apart. Anthropic's own "40% less to run than Opus 5" claim also counts Opus 5.5 using fewer tokens per task, which a fixed-token example can't capture.

Example 3: a 10,000-document batch job

Classify or summarize 10,000 documents. Each request has a 6,000-token shared instruction prefix, a 4,000-token document and a 1,000-token answer.

• Standard API, no caching: 100M input tokens × $4 + 10M output × $20 = $600.
• Batch API, no caching: half of that, $300.
• Batch plus caching, best case: if the shared 6K prefix is written once at the Batch 1-hour rate and every other request reads it at $0.10 per million, the total drops to roughly $186. Batch cache hits are best-effort, so plan on landing somewhere between $186 and $300.

If you'd like to run these numbers on your own traffic, paste your workload into the prompt below.

Opus 5.5 vs Opus 5, Fable 5.1, Sonnet 5.5 and Gemini 4 Argon on Price

Here's how Opus 5.5 lines up with its siblings and its closest Google rival, per million tokens on standard first-party APIs:

vs Opus 5. Opus 5.5 is cheaper on every line: 20% lower input, output and cache writes, and 60% lower cache reads. Anthropic's models overview now says to "start with Claude Opus 5.5 for most workloads".

vs Fable 5.1. Fable costs 2.5x as much per token, though its cache reads are only slightly dearer ($0.25). Anthropic positions it for "demanding reasoning and long-horizon agentic work", or when Opus 5.5 at higher effort still falls short in your evals. We compared it with OpenAI's flagship in GPT-6 Astra vs Claude Fable 5.1.

vs Sonnet 5.5. Sonnet is exactly half the price on every line, with the same 5% cache-read multiplier and "Fast" rather than "Moderate" latency in Anthropic's table. If it passes your evals, it's the obvious first saving.

vs Gemini 4 Argon. Until November 30, Argon costs half as much. From December 1 the list prices match exactly, $4 and $20 with $0.20 cached input. Then structure decides: Claude offers explicit caching and a paid fast mode; Argon caches implicitly (prompts of 4,096+ tokens) and sells latency through a Priority tier. Gemini implicit caching vs Claude explicit caching explains how that changes real bills, and Gemini 4 Argon vs Claude Opus 5.5 covers benchmarks.

For routine coding and agent steps, Z.ai's GLM models are also worth testing alongside Sonnet 5.5 before you commit Opus-level budget to every call.

Using Opus 5.5 on Claude Plans: Pro, Max, Team and Enterprise

You don't need the API to use Opus 5.5. Anthropic's pricing page lists Opus as included on every paid plan, but not on Free:

A few details change the maths for subscribers:

• Usage is pooled and limited, not per-token. Limits reset on a rolling five-hour window (plus weekly limits on paid plans), and chats and Claude Code share one pool. Anthropic raised five-hour limits on Pro, Max, Team and seat-based Enterprise with the Opus 5.5 launch.
• Usage credits are billed at API rates. When you hit a limit on a paid plan, you can turn on usage credits and keep working at standard API rates. Fast mode in Claude Code always bills to these credits.
• Max and Team API credits come with strings attached. They cover the Claude API, Managed Agents and the Agent SDK, but not Claude Code or extra app usage, work only in the Claude Console and don't roll over. At Opus 5.5 rates, $100 buys 25 million input tokens or 5 million output tokens.
• Enterprise is seat plus metered usage: $20 per seat, then Opus 5.5 tokens at API rates.

For a full plan-by-plan feature comparison, see our Claude Pro, Max, Team and Enterprise pricing guide and, if you're choosing between ecosystems, Claude Max vs ChatGPT Pro.

Verdict: Cheaper Than Opus 5 Everywhere, Cheapest When Cached

Honest answer: Opus 5.5 is the best-value Opus Anthropic has shipped, and caching is what makes it cheap. It undercuts Opus 5 on every line, and its $0.20 cache reads turn our 40-turn agent session from a $14 problem into a $3.56 one. Batch halves everything again and stacks with caching down to $0.10 reads.

Use fast mode deliberately. Double the price for up to 2.5x faster output is worth it for live coding and debugging, but switching mid-conversation re-bills your whole context. Decide per session, not per message.

Our take on who should pay for what:

• Building agents or coding tools: standard Opus 5.5 with aggressive caching and effort tuned per step. Reach for effort settings before you reach for a smaller model.
• Bulk processing: Batch API plus 1-hour caching on the shared prefix.
• Latency-sensitive interactive work: fast mode from the first turn of the session, ideally with lower effort on simple steps.
• Individual users: Pro is the cheapest way in; Max 5x once you hit Pro limits daily, with $100 of monthly API credits as a bonus.
• Price-sensitive teams: test Sonnet 5.5 first, and compare with Gemini 4 Argon while its introductory rates last.

One caution: these are October 2026 list prices, and Anthropic notes prices and plans can change, so re-check before you sign a budget.

Keep Reading

• 25 Best Claude Opus 5.5 Prompts for Coding
• 12 Context Engineering Patterns for Claude Code Agents
• How to Write AGENTS.md and CLAUDE.md Files That Actually Work