Claude Opus 5.5 Developer Guide: Pricing, API, Claude Code

Claude Opus 5.5 (API model id claude-opus-5-5) is Anthropic's newest Opus model, released September 22, 2026, and the model Anthropic's docs now tell you to start with for most workloads. It costs $4/$20 per million input/output tokens - 20% less than Opus 5 - with cache reads at $0.20, a 1M-token context window, and thinking that is always on, steered by an effort setting that defaults to medium. Should you use it? If you are on Opus 5 today, yes: it is cheaper, faster, and in Anthropic's testing matches Opus 5 at high effort while running at medium - just budget an afternoon for four breaking API changes. Against the rest of the 5.5 family, use Opus 5.5 for long-horizon work and review, and default everyday coding to Sonnet 5.5, which is half the price on every line and leads Terminal-Bench 4.0.

Last updated: October 8, 2026 - decision guide and FAQ rewritten against Sonnet 5.5 and Haiku 5.5, and pricing re-verified after the October 7 Sonnet 5.5 cache-read cut (Opus 5.5 rates unchanged). Model ids, parameters, and Claude Code setup were verified September 28, 2026.

This guide is example-first: SDK calls in TypeScript and Python, the Claude Code setup, the migration diffs from Opus 5, and three before/after prompts that show where 5.5 behaves differently. A note on how the examples were checked: no Anthropic API key was available in the environment used to write this post, so the SDK snippets were type-checked against the current SDKs (@anthropic-ai/sdk 0.128.0 and anthropic 1.8.0 for Python, with tsc --strict and mypy) and verified against the platform docs, but not executed. No model output is shown, because we did not generate any.

At a Glance#

Official Sources#

What's New vs Opus 5 and Fable 5.1#

Opus 5.5 is the first model in the Claude 5.5 family. Sonnet 5.5 followed on September 28, 2026 (see the Sonnet 5.5 release guide for its benchmarks, pricing, and API changes), and Haiku 5.5 completed the lineup on October 7. Against the models we have covered before:

• vs Opus 5: 20% lower input and output prices, 60% cheaper cache reads ($0.50 to $0.20), output generated more than 30% faster, and fewer tokens per task. Anthropic's announcement frames that as 40% lower cost on typical workloads. Writing is the other headline: clearer messages with the important information up front, answering the most common complaint about Opus 5.
• vs Fable 5.1: Anthropic claims Fable 5.1-level results on most work at 40% of the per-token price ($4/$20 vs $10/$50). The docs still point you to Fable 5.1 for the most demanding reasoning and long-horizon work, "or when your evals on Claude Opus 5.5 at higher effort still fall short." Our Opus 5 vs Opus 4.8 vs Fable 5 comparison is the baseline this release resets.
• Visual inputs: per the prompting guide, Opus 5.5 reads values off dense charts more accurately at its lowest effort than Opus 5 did at its highest, and it is more reliable at multi-step computer use.

And four breaking changes for code already running on Opus 5, straight from the what's-new doc:

1. Thinking can't be disabled. thinking: {type: "disabled"} and {type: "enabled", budget_tokens: N} both return a 400. Omit thinking (or send {type: "adaptive"}) and use output_config.effort instead.
2. Forced tool use is gone. tool_choice of any or tool returns a 400. Use auto plus strict: true, or structured outputs.
3. Thinking blocks are tied to the model and the conversation. Edit the system prompt, tools, or an earlier message after a thinking block was produced and, on accounts created on or after August 31, 2026, replaying that block is a 400. Keep histories append-only.
4. Computer use goes through the toolset. On the Claude API and Google Cloud, the old computer_20251124 tool is rejected; use computer_toolset_20260801. Bedrock still accepts the old tool.

One quieter change: short notes between tool calls now arrive as thinking blocks, empty by default. If your UI streams those notes, it goes silent until you set thinking.display to "updates" (beta).

Benchmarks#

Vendor-reported, from the announcement. Opus 5.5 results use adaptive thinking at max effort unless noted, and the model was evaluated with production safeguards on: when they intervened, cybersecurity tasks were completed by Opus 4.8 and biology and frontier-LLM-development tasks by Opus 5.

The number worth remembering is the efficiency one: at default medium effort, Opus 5.5 scores 54.6% on FrontierCode, above GPT-6 Astra's top score (53.3%), for about a fifth of the cost per task, per Anthropic. Cross-vendor rows use different harnesses and settings, so treat them as directional. For how this landed against the other launches that week, see the GPT-6 Sol vs Opus 5.5 vs Grok 4.7 price war.

Pricing#

First-party API pricing per 1M tokens, re-verified on the pricing page October 8, 2026:

Fast mode is a research preview, Claude API only, and runs up to 2.5x faster. The full 1M context is billed at standard rates. Bedrock and Google Cloud set their own prices.

Opus 5.5's cache read stays at $0.20 per million tokens, while Sonnet 5.5's dropped from $0.20 to $0.10 on October 7, so the two 5.5 models no longer share a cache rate and Sonnet 5.5 is now half of Opus 5.5 on every line. If you have a Max or Team plan, the new monthly Claude API credit ($100 on Max 5x, $200 on Max 20x, up to $500 pooled on Team) covers Messages API calls, so it is a free way to run your own Opus 5.5 evals.

Worked example for agent work, where cache reads dominate: a session that reads a 200K-token repository prefix from cache 40 times spends $1.60 on cache reads on Opus 5.5 versus $4.00 on Opus 5, and 50K output tokens cost $1.00 versus $1.25. That is the same math we ran for parallel Claude agent fleets - on cache-heavy loops the real saving runs well past the sticker 20%.

Example 1: Call Opus 5.5 From TypeScript#

Install the SDK (npm install @anthropic-ai/sdk), export ANTHROPIC_API_KEY, and run this as an ES module:

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic(); // reads ANTHROPIC_API_KEY

const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 16000,
  // Thinking is always on for Opus 5.5 - effort is the dial.
  // The default is "medium"; set it explicitly so the cost profile is intentional.
  output_config: { effort: "medium" },
  messages: [
    {
      role: "user",
      content:
        "Review this function for bugs and reply with a numbered list:\n\n" +
        "function avg(xs: number[]) { return xs.reduce((a, b) => a + b) / xs.length }",
    },
  ],
});

if (response.stop_reason === "refusal") {
  console.error("Declined:", response.stop_details);
} else {
  // Read blocks by type - a response can start with (empty) thinking blocks.
  for (const block of response.content) {
    if (block.type === "text") console.log(block.text);
  }
}
console.log(response.usage);

Two details matter here. Responses can begin with thinking blocks whose text is empty at the default display: "omitted", so response.content[0].text is a bug waiting to happen - filter by type. And Opus 5.5 runs safety classifiers (cyber, bio, and a new reasoning_extraction category), so a decline comes back as HTTP 200 with stop_reason: "refusal", not an exception.

Example 2: The Same Call in Python#

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    output_config={"effort": "medium"},  # thinking is always on; effort is the dial
    messages=[
        {
            "role": "user",
            "content": "Review this function for bugs and reply with a numbered list:\n\n"
            "def avg(xs): return sum(xs) / len(xs)",
        }
    ],
)

if response.stop_reason == "refusal":
    print("Declined:", response.stop_details)
else:
    for block in response.content:  # read by type, not position
        if block.type == "text":
            print(block.text)
print(response.usage)

Example 3: Long Tasks - Stream, Raise Effort, See the Reasoning#

For anything with a big max_tokens, stream so the request does not hit HTTP timeouts. display: "summarized" returns a readable summary of the thinking instead of empty blocks:

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const stream = client.messages.stream({
  model: "claude-opus-5-5",
  max_tokens: 64000,
  // "summarized" returns a readable summary of the reasoning (default is "omitted")
  thinking: { type: "adaptive", display: "summarized" },
  output_config: { effort: "high" },
  messages: [
    {
      role: "user",
      content: "Plan a migration from REST polling to webhooks for a billing service.",
    },
  ],
});

stream.on("text", (delta) => process.stdout.write(delta));
const final = await stream.finalMessage();
console.log("\n", final.usage);

Size max_tokens for thinking plus reply. The prompting guide notes that Opus 5.5 thinks more per turn than Opus 5 at the same effort level, most of all at xhigh and max, and that 128K (the model maximum) has worked well for long agentic coding turns. We covered how effort levels trade depth for tokens in Fable 5 effort levels explained; the same mental model applies here, just with medium as the new starting point.

Example 4: Migrating Opus 5 Code (Before and After)#

The two breaking changes most codebases hit are a disabled-thinking route and a forced tool call. Here is the fix for both, in Python:

import anthropic
from anthropic.types import ToolParam

client = anthropic.Anthropic()

get_weather: ToolParam = {
    "name": "get_weather",
    "description": "Get the current weather for a city.",
    "input_schema": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"],
        "additionalProperties": False,
    },
    "strict": True,  # arguments always match the schema
}

# Before (Opus 5): thinking={"type": "disabled"} and
# tool_choice={"type": "tool", "name": "get_weather"} - both return 400 on Opus 5.5.

# After (Opus 5.5): effort replaces the thinking switch, auto + strict replaces forcing.
response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    output_config={"effort": "low"},
    tools=[get_weather],
    tool_choice={"type": "auto"},
    messages=[
        {"role": "user", "content": "What's the weather in Paris? Use the get_weather tool."}
    ],
)

if not any(block.type == "tool_use" for block in response.content):
    print("No tool call - retry or fall back to a text answer")

low effort is the documented replacement for thinking-disabled routes: the model keeps its thinking short, and you move to medium if quality drops. Because auto does not guarantee a call, the check at the end is not optional.

Example 5: Use Opus 5.5 in Claude Code#

On the Anthropic API, Claude Code's opus alias now resolves to Opus 5.5 (Claude Code v2.1.280 or later). Check your version, then pick the model at launch or mid-session:

claude --version            # needs 2.1.280+
claude --model opus         # launch on Opus 5.5
claude --model opus --effort high

Inside a session:

/model opus        # switch to Opus 5.5
/model opus[1m]    # Opus 5.5 with the 1M context window
/effort medium     # or open /effort with no argument for the slider

Or make it the default in settings.json:

{
  "model": "opus",
  "effortLevel": "medium"
}

ANTHROPIC_MODEL=opus and CLAUDE_CODE_EFFORT_LEVEL=high work as environment variables too. The Claude Code docs recommend starting at medium when you move from Opus 5 rather than carrying over your old level. One provider gotcha: on Microsoft Foundry the opus alias still maps to Opus 4.6, so pass the full model id there if your deployment has it.

Example 6: OpenCode#

OpenCode Zen lists the model as opencode/claude-opus-5-5 at the same $4/$20 rates:

curl -fsSL https://opencode.ai/install | bash
opencode run --model opencode/claude-opus-5-5 --variant high \
  "find the flakiest test in this repo and explain why it fails"

The --variant flag picks the effort level. The same setup pattern is in our DeepSeek V4 Flash OpenCode guide if you want to route cheap edits to one model and hard loops to Opus 5.5.

Before and After: Three Prompts That Change on Opus 5.5#

These are our own prompts, rewritten according to Anthropic's Opus 5.5 prompting guide. Each "after" addresses a behavior the guide documents.

1. Stop asking it to show its work in the answer#

Before (a pattern written for thinking-disabled routes on older models):

Think step by step. Write out all of your reasoning before giving the final answer,
then give the answer on the last line.

After:

Answer the question directly. Lead with the answer, then give at most three
sentences of justification.

Plus output_config: { effort: "low" } and, if you need the reasoning for logs, thinking: { type: "adaptive", display: "summarized" }. Why: thinking is always on now, and a prompt that pushes the model to reproduce its internal reasoning in the response can be declined under the new reasoning_extraction category. Read the reasoning from summarized thinking blocks instead of the reply.

2. Tell an unattended agent which early stops you do not want#

Before:

Migrate every endpoint in src/api from Express to Hono. Keep going until done.

After:

Migrate every endpoint in src/api from Express to Hono. Track each endpoint in
MIGRATION.md as a checklist and tick items off as their tests pass.

Nobody is watching this run. Do not end a turn with a summary that announces the
next step, an offer to continue, or a list of non-blocking decisions - take the next
step instead, and put any status note in the same message as your next tool call.
Only stop when every item is ticked, or when something you cannot resolve blocks
all remaining work; in that case, say exactly what is blocking.

Why: Opus 5.5 reports progress on long multi-part tasks, and some of those reports end the turn with text. An unattended loop that treats that as "done" stops halfway. The guide recommends naming the specific kinds of early stop to avoid, keeping a checklist the model updates, and having your harness send a short "these items are still open" message (capped at two or three continuations) when a turn ends early.

3. Name the design defaults, not the vibe#

Before:

Build a landing page for a developer CLI. Make it not look like generic AI output.

After:

Build a landing page for a developer CLI in plain HTML and CSS. Do not use a
centered hero with a gradient blob, emoji feature icons, three identical feature
cards, or pill-shaped buttons. Use a two-column layout with a real terminal
transcript on the right.

Why: per the guide, Opus 5.5 falls back on a few default styles when given no direction, and a general "avoid the generic look" instruction mostly swaps one default for another. Listing the specific patterns to avoid works better - check what the first result used and extend the list.

When to Use Opus 5.5 vs Sonnet 5.5 or Haiku 5.5#

Prices, limits, latency, and effort defaults are from the models overview and pricing page; Terminal-Bench 4.0 scores are vendor-reported in each model's launch post, so treat them as directional.

The 5.5 family changed this decision. Sonnet 5.5 scores higher than Opus 5.5 on Terminal-Bench 4.0 in Anthropic's launch numbers (70.6% vs 66.4%) at half the price on every line, so Opus is no longer the default for everyday coding. Treat the gap as directional: readers of the system cards point out that a larger share of Opus 5.5's Terminal-Bench trials were answered by a fallback model after safeguards intervened, so confirm it on your own tasks. Anthropic's own framing is that Opus 5.5 "remains clearly stronger at complex, open-ended work requiring sustained judgment", and that is where it earns its price.

Pick Opus 5.5 when the work is long-horizon, open-ended, or review-shaped: migrations across a real repository, audits, code review, financial models, and long unattended agent loops where fewer retries matter more than the token price. It is also the drop-in upgrade for anyone on Opus 5. For a long-loop case outside code, the channel's browser 3D world build runs Opus 5.5 against a creative MCP connector over several days of prompt-test-iterate.

Pick Sonnet 5.5 when the task is well scoped: feature work, bug fixes, and higher-volume agent turns. At higher effort Anthropic says the two can perform comparably at a similar cost, so compare cost per completed task rather than assuming the cheaper sticker wins.

Pick Haiku 5.5 when latency and volume dominate: summaries, compaction, classification, routing, and subagent steps under an Opus or Sonnet orchestrator. Keep prompts under 100K tokens to stay on the low price tier.

Pick Fable 5.1 when your evals on Opus 5.5 at xhigh or max still fall short. That is Anthropic's own guidance, and it is a better test than any benchmark row.

FAQ#

What is Claude Opus 5.5?#

Anthropic's Opus-tier model released September 22, 2026, and the first model in the Claude 5.5 family. It is built for long-running agentic coding and knowledge work, costs $4/$20 per million input/output tokens, and has a 1M-token context window with 128K max output.

What is the Claude Opus 5.5 model id?#

claude-opus-5-5 on the Claude API, Claude Platform on AWS, Google Cloud, and Microsoft Foundry; anthropic.claude-opus-5-5 on Amazon Bedrock. There is no date suffix - the dateless id is itself a pinned snapshot.

Can I turn off thinking on Opus 5.5?#

No. thinking: {type: "disabled"} and budget_tokens both return a 400. Lower output_config.effort to low for fast, cheap responses; effort controls thinking depth, latency, and cost.

How do I use Opus 5.5 in Claude Code?#

Update to Claude Code v2.1.280 or later, then run claude --model opus or type /model opus in a session (/model opus[1m] for the 1M context window). On the Anthropic API the opus alias resolves to Opus 5.5. Set effort with /effort or --effort.

Should I use Opus 5.5 or Sonnet 5.5?#

Default everyday coding and well-scoped agent work to Sonnet 5.5, which costs half as much on every line. Use Opus 5.5 for long-horizon, open-ended work and code review, where Anthropic says it remains clearly stronger, and compare cost per completed task on your own work. The Sonnet 5.5 guide has the full price comparison and decision table.

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, 5-minute cache writes at $5, and batch at $2/$10. Fast mode (research preview) is $8/$40. The full 1M context window is billed at the standard rate.

Sources#

All fetched September 28, 2026 unless noted; pricing, models overview, and the Sonnet 5.5 and Haiku 5.5 announcements re-checked October 8, 2026.

Continue Reading#

• Claude Opus 5 vs Opus 4.8 vs Fable 5: Full Benchmark Comparison - the July shootout this release resets
• Claude Opus 5 in 8 Minutes - the previous Opus launch, for the before/after
• Claude Sonnet 5.5 Developer Guide - the half-price sibling that leads Terminal-Bench 4.0
• Claude Max API Credits - the monthly API credit Max and Team plans now include
• GPT-6 Sol vs Claude Opus 5.5 vs Grok 4.7 - how Opus 5.5 prices against the other September launches
• What Parallel Claude Agents Actually Cost - cost-per-task math for agent fleets
• Opus 5.5 in Claude Code: The Playbook and Where It Breaks - the prompting and CLAUDE.md habits the vendor recommends, and what the community reports
• Claude Haiku 5.5 Developer Guide - the cheap subagent tier that launched October 7
• Melty Game Mashups: How Claude Code Builds Them - Opus-built game mashups and the modder backlash