Claude Sonnet 5.5 Released: How It Differs from Sonnet 5, 5 Breaking Changes That Return 400 Errors, and How to Choose Between It and Opus 5.5

On September 28, 2026, Anthropic released Claude Sonnet 5.5. According to the announcement, it is the second model in the Claude 5.5 family, following Opus 5.5 six days earlier, and the previous Sonnet 5 (released June 30, 2026) has moved to Legacy (older, but still available). The official model overview describes it as the model with the best combination of speed and intelligence.

The short version: pricing is exactly the same as Sonnet 5 ($2 input, $10 output and $0.20 cache reads per million tokens), and in Anthropic's comparison table it improves substantially on Sonnet 5 in most rows. The API behaves differently, though: there are five changes that make code that worked on Sonnet 5 fail with a 400 error. Most notably, thinking: {"type": "disabled"} no longer works for turning thinking off, and its replacement, between_tools, is accepted only at effort high or below. This article checks the official documentation and the announcement against each other in the original text and walks through, in the order you will need it, what changed, what breaks when you migrate, and how to choose between it and Opus 5.5.

Information as of September 29, 2026: written the day after launch, after reading the original text of the official Claude Platform documentation (Models overview, the Sonnet 5.5 page, What's new, the migration guide, Pricing, Thinking, Effort and Prompt caching), Anthropic's announcement, the Claude Code documentation and CHANGELOG, and the GitHub changelog. Claude Haiku 5.5, which the announcement says is coming within weeks, had not been released at this point.

1. Sonnet 5.5 at a glance: performance, pricing, migration pitfalls

In one sentence, Sonnet 5.5 is a Sonnet that moved up a tier at the same price, handled with almost the same conventions as Opus 5.5. Three of the five breaking changes (forced tool use, thinking-block binding and the legacy computer use tool) also apply to Opus 5.5 and Fable 5.1. What is specific to Sonnet 5.5 comes down to two things: a way to cut thinking survives as a separate value, between_tools, and there are restrictions on advisor tool pairings.

2. Core specs and availability

The comparison covers three models: Sonnet 5, which it replaces; Opus 5.5 above it; and Haiku 4.5 below it.

Sources: Anthropic, "Models overview", "Claude Sonnet 5.5", "Claude Sonnet 5" and "Prompt caching" (checked September 29, 2026). Speed is a relative label within the current lineup and is not listed for the Legacy Sonnet 5. Retirement dates are commitments for platforms Anthropic operates; Amazon Bedrock and Google Cloud set their own.

Only three rows differ from Sonnet 5: thinking, knowledge cutoff and minimum cacheable length. Context, max output and the API's default effort are the same, and the tokenizer is also the same as Sonnet 5, so the same text produces the same number of tokens (What's new). On the Message Batches API, adding the beta header output-300k-2026-03-24 raises the output limit to 300K tokens (the same as Sonnet 5). Also note that sending non-default values for temperature, top_p or top_k returns a 400. That was already true on Sonnet 5, so it only matters if you are moving directly from Sonnet 4.6 or earlier.

Where it's available

3. Pricing: the same as Sonnet 5, except for the cache minimum

The official What's new page says it is priced the same as Sonnet 5, with prompt caching and batch processing priced the same as well. Here are the detailed rates.

Source: Anthropic, "Pricing" (checked September 29, 2026). The Batch API is 50% off standard rates for both input and output.

Two things that can change within "the same price"

Identical rates don't guarantee an identical bill. Two factors can change it.

The first is the minimum cacheable length. On Sonnet 5, prompts shorter than 1,024 tokens were not cached even with cache_control. On Sonnet 5.5 this floor has dropped to 512 tokens. For example, a job that sends an 800-token system prompt plus tool definitions on every call was not eligible for caching on Sonnet 5, but it is cached on Sonnet 5.5. You can tell whether something was cached from the response's usage: if cache_creation_input_tokens and cache_read_input_tokens are both 0, nothing was cached (official Prompt caching page). Falling short of the minimum doesn't raise an error, so while you migrate it's worth checking for jobs where caching was silently not taking effect.

The second is the number of tokens per task. The announcement says it needs far fewer tokens for the same work, that in Anthropic's testing it is up to 30% cheaper per task, and that it generates output more than 30% faster than Sonnet 5. Those are Anthropic's own measurements. At the same time, the official documentation says that the effort levels have been recalibrated, so the same level won't necessarily think as much as it did on Sonnet 5. Thinking tokens are billed as output tokens even when they aren't displayed. After migrating, the only way to know is to measure usage and compare on your own workload.

The gap to Opus 5.5 isn't "2×" because cache reads alone cost the same $0.20 on Opus 5.5. The higher the cache share of an agentic workload, the less you save by choosing Sonnet 5.5. Pricing across all Claude models is covered in our Opus, Sonnet and Haiku pricing comparison.

4. Benchmarks: reading them within Anthropic's table

The announcement's comparison table has four columns: Sonnet 5.5, Sonnet 5, Opus 5.5 and GPT-6 Sol. Here are the table's conditions first.

• The table comes from Anthropic's announcement, and most rows are Anthropic's own measurements. The exceptions are GDPval-AA v2.1 and AA-Briefcase v1.1, which were run by Artificial Analysis (footnote 3).
• Artificial Analysis ran those tests in a pre-release environment that had a bug which could degrade responses to requests using structured outputs. Anthropic notes that any effect would be small and would make the scores look lower, and says the bug has been fixed.
• Opus 5.5's Terminal-Bench 4.0 figure is at xhigh and is Opus 5.5's best score (footnote 1). Sonnet 5.5's FrontierCode has two figures: 46.2% at max and 52.1% at xhigh (footnote 2).
• GPT-6 Sol's GDPval-AA, AA-Briefcase and Chartography scores carry a note that they may predate OpenAI's fix for an image-understanding bug (footnote 4).

Source: the comparison table and footnotes in Anthropic's "Introducing Claude Sonnet 5.5" (September 28, 2026; checked September 29). Bold marks the highest value in each row; "—" means the table has no value. Details of the methodology are in the Sonnet 5.5 system card linked from the same announcement.

Three things stand out.

• The jump from Sonnet 5 is large. Terminal-Bench 4.0 went from 10.3% to 70.6%, and Chartography (without tools) from 15.6% to 61.6%: several times higher within the same table. GDPval-AA rose by about 400 points.
• The gap to Opus 5.5 is within a few points in most rows. GDPval-AA is 2 points apart, CursorBench 2.3 points and OSWorld 2.1 1.7 points. On Terminal-Bench 4.0, Sonnet 5.5 beats Opus 5.5's best score (66.4% at xhigh).
• Anthropic still places Opus 5.5 above it. The announcement says that benchmarks capture only one side of capability, and that both internally and among outside testers, Opus 5.5 remains clearly stronger on complex, open-ended work that requires sustained judgment.

Cost by effort level: from the announcement's chart descriptions

The announcement also has charts plotting score against cost per task for each effort level. Here is what their descriptions say.

Source: chart descriptions in Anthropic's "Introducing Claude Sonnet 5.5." The Terminal-Bench and CursorBench charts show GPT-5.6 Sol because GPT-6 Sol's scores have not been published (note on the same page).

The two FrontierCode figures deserve attention. Sonnet 5.5 scores lower at max (46.2%) than at xhigh (52.1%). According to the footnote in Anthropic's announcement, at max it more often ran Claude Code's code-review skill and split work across many subagents, which in some cases led to timeouts and edits outside the task's scope. Raising effort doesn't always raise the score, so pick the level by comparing on your own work (Section 7). GPT-6 Sol's numbers are covered in our GPT-6 Sol and Luna release overview.

5. Five breaking changes that return a 400 when you move from Sonnet 5, and the fixes

The official What's new in Claude Sonnet 5.5 lists five breaking changes that affect code working on Sonnet 5. Each one fails with a 400 invalid_request_error.

① To turn thinking off, use between_tools instead of disabled

On Sonnet 5, thinking: {"type": "disabled"} turned thinking off at any effort level. On Sonnet 5.5, disabled returns a 400 with this message:

"thinking.type.disabled" is not supported for this model. Use "thinking.type.between_tools" for the lowest thinking setting, or "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.

The replacement is thinking: {"type": "between_tools"}, the lowest thinking setting on this model, which stops the "upfront thinking" the model does before answering. For requests without tools, the response contains only text, just as with disabled on Sonnet 5. No beta header is needed, and it works on every platform that offers Sonnet 5.5. But if you swap it in as a drop-in for disabled, three things will trip you up.

• It returns a 400 at effort xhigh and max. between_tools is accepted only at low, medium and high. For jobs that ran "xhigh with thinking off" on Sonnet 5, you have to either lower effort to high or below, or stop turning thinking off.
• You can't send other fields with it. Sending display, budget_tokens or block_binding together with between_tools returns a 400.
• You can't change effort mid-conversation. Sending a different level with per-message effort (beta) returns a 400. If you want to vary the level per turn, use adaptive thinking (omit thinking or send {"type": "adaptive"}).

Here is the migration guide's before-and-after example in Python. Note that because the "before" example uses xhigh, the "after" example lowers it to high.

# Before: works on Sonnet 5, returns 400 on Sonnet 5.5
client.messages.create(
    model="claude-sonnet-5",
    max_tokens=16000,
    thinking={"type": "disabled"},
    output_config={"effort": "xhigh"},
    messages=[{"role": "user", "content": "..."}],
)

# After: stop upfront thinking; effort must be high or below
client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=16000,
    thinking={"type": "between_tools"},
    output_config={"effort": "high"},
    messages=[{"role": "user", "content": "..."}],
)

Even with between_tools, the short progress notes the model writes between tool calls come back as thinking blocks with summary text. Don't discard them; send them back unchanged along with the rest of the assistant turn. From the blocks you send back, the model receives the full text of the notes it wrote (What's new). A manual budget, {"type": "enabled", "budget_tokens": N}, still returns a 400, as on Sonnet 5.

② Forced tool use returns an error

Setting tool_choice to {"type": "any"} or {"type": "tool", "name": "..."} returns a 400. The token counting API applies the same check. Only auto (the default) and none are allowed.

tool_choice: type "tool" and "any" are not supported for this model.

Fix: keep tool_choice at auto and add strict: true to the tool definitions (strict tool use), or move the schema to structured outputs. With auto, the model may answer in text without calling the tool, so state in the prompt when it should use that tool. Strict tool use accepts only a subset of JSON Schema, and every object in the schema needs additionalProperties: false. You can make up to 20 tools strict per request, and strict can't be set on MCP, computer use or browser use toolsets.

# Before: works on Sonnet 5, returns 400 on Sonnet 5.5
client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "tool", "name": "get_weather"},
    messages=[{"role": "user", "content": "What's the weather in Paris?"}],
)

# After: auto + strict; say in the prompt when to use the tool
client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=1024,
    tools=[{**tool, "strict": True} for tool in tools],
    tool_choice={"type": "auto"},
    messages=[{"role": "user",
               "content": "What's the weather in Paris? Use the get_weather tool."}],
)

Amazon Bedrock is different. Structured outputs (including strict tool use) aren't available for Sonnet 5.5 on Bedrock, so send auto without strict, state in the prompt when to call the tool, and validate tool inputs in your own code (migration guide).

③ Thinking blocks are bound to the model and the conversation

Each thinking block records which model produced it. Sonnet 5.5 can read thinking blocks from Sonnet 5, Opus 4.8, Haiku 4.5 and earlier models, but not from Opus 5, Opus 5.5, Fable or Mythos. And no other model can read Sonnet 5.5's thinking blocks.

• Switching from Sonnet 5 to Sonnet 5.5 carries the earlier reasoning over.
• Switching from Sonnet 5.5 to any other model means the turns after the switch run without Sonnet 5.5's reasoning. The request itself succeeds, and the dropped blocks are not billed.

Fable 5.1 and Mythos 5.1 can read Opus 5.5's thinking blocks, but nobody can read Sonnet 5.5's. If you route "only the hard parts up from Sonnet 5.5 to Opus 5.5," test on the assumption that Sonnet 5.5's reasoning disappears at the model you escalate to.

There is one more check: whether everything before a Sonnet 5.5 thinking block (system, tools and earlier messages) has changed since the block was produced. For accounts created on or after August 31, 2026, 00:00 UTC, this is enforced by default on the Claude API, Amazon Bedrock and Google Cloud, and sending a block with a history that was rewritten along the way returns a 400.

Fix: advance the conversation by appending only. When you want to change instructions or tools, use a mid-conversation system message instead of rewriting history (a feature newly available on Sonnet 5.5 that Sonnet 5 doesn't have). If rewriting is unavoidable, add the beta header thinking-binding-controls-2026-08-01 and set thinking.block_binding.prefix_mismatch_behavior to "drop_block" to have the affected blocks discarded instead of raising an error. But block_binding works only with adaptive thinking, so with between_tools, either append only, or remove the thinking blocks from the rewritten turn onward yourself.

④ The legacy computer use tool is rejected on the Claude API and Google Cloud

Sonnet 5 also accepted computer use through the legacy tool computer_20251124 with a beta header. Sonnet 5.5 on the Claude API and Google Cloud accepts only the toolset computer_toolset_20260801, and declaring the legacy tool returns a 400. On the Claude API, the message starts with:

'claude-sonnet-5-5' does not support tool types: computer_20251124.

Fix: remove the beta header, replace tools with [{"type": "computer_toolset_20260801"}], and update your agent loop to the toolset's shape (tool_use blocks for members, multiple actions at once, and toolset_name in results). If you send the fine-grained-tool-streaming-2025-05-14 beta header, remove it. Sending it together with the toolset returns a 400, so add eager_input_streaming: true to each tool that needs it. On Amazon Bedrock the legacy tool still works, so no change is needed.

⑤ Some advisor tool pairings are rejected

The advisor tool (beta) lets an executor model ask a stronger model for advice. When Sonnet 5.5 is the executor, specifying Opus 4.8, Opus 4.7, Opus 4.6, Sonnet 5 or Sonnet 4.6 as the advisor returns a 400. The allowed advisors are Opus 5, Opus 5.5, Sonnet 5.5, Fable 5, Fable 5.1, Mythos 5 and Mythos 5.1.

In addition, every advisor that Sonnet 5.5 accepts returns its advice in an encrypted advisor_redacted_result block, so the client can't read the text of the advice. Anything that logged the advice or displayed it on screen needs rebuilding. Cheap pairings such as "Sonnet 5 as executor, Opus 4.8 as advisor" can't carry over as-is to Sonnet 5.5.

6. Changes that happen without an error

The five breaking changes raise a 400, so you'll notice them. The tricky ones are changes in behavior that don't raise any error.

Sources: What's new in Claude Sonnet 5.5, Migrating to Claude Sonnet 5.5, Anthropic's announcement

The announcement also describes changes to safeguards. Sonnet 5.5 is the first Sonnet to ship with cyber safeguards and a fallback, because its capabilities usable for cyberattacks have reached the level of Opus 5; high-risk cybersecurity work visibly switches to Sonnet 5. Finding and fixing bugs in everyday development is not affected. Biology safeguards are the same as on Sonnet 5.

On the other hand, some features were added. Per-message effort (beta; lets you change the level while keeping the prompt cache), mid-conversation system messages and mid-conversation tool changes (beta) were all unavailable on Sonnet 5. What's new also lists compaction, which summarizes the conversation whenever you ask (beta, header compact-2026-09-04), and defining tools inside messages (beta, header inline-tools-2026-09-15).

7. Default effort: high on the API, medium in Claude Code

Opus 5.5 lowered its default effort to medium even on the API, but Sonnet 5.5 keeps high as the API default. Meanwhile, the announcement says the default in Claude Code and the apps is now medium. The same Sonnet 5.5 thinks one level differently by default on the API and in Claude Code.

The official effort page recommends these starting points for Sonnet 5.5:

Sources: "Recommended effort levels for Claude Sonnet 5.5" in Anthropic, "Effort", and the migration guide

The same page also recommends setting max_tokens large enough for both thinking and the response, and, for agentic coding, setting max_tokens to this model's limit of 128,000 and receiving the response via streaming. Thinking tokens count toward max_tokens even in settings where the thinking content isn't returned. How effort itself works is covered in our guide to the effort setting, and adaptive thinking in adaptive vs. extended thinking.

8. Choosing between Sonnet 5.5, Opus 5.5 and Haiku

The official model overview still says to start with Opus 5.5 if you're unsure; Sonnet 5.5 has not become the starting point. With that said, the announcement describes Sonnet 5.5's strengths as well-scoped everyday work, bug fixes, and creating documents, slides and spreadsheets, and Opus 5.5's as complex work that needs careful judgment. It also says that Sonnet 5.5 complements Opus 5.5 best at lower effort, and that at higher levels the two can reach similar performance at similar cost. In other words, if you run at xhigh or max, choosing Sonnet 5.5 gives you little cost advantage.

When in doubt, go in this order: ① run Sonnet 5.5 at medium and high on your own work → ② if that falls short, compare with Opus 5.5 at medium → ③ if Sonnet 5.5 at xhigh costs about the same as Opus 5.5, choose Opus 5.5. Opus 5.5 is covered in detail in our Opus 5.5 release overview, and the full list of current models in major AI models and their knowledge cutoffs.

9. Using it in Claude Code and GitHub Copilot

Claude Code added Sonnet 5.5 in the v2.1.284 CHANGELOG (September 28, 2026) and made it the default Sonnet on the Anthropic API.

Sources: Claude Code, "Model configuration" and the CHANGELOG (v2.1.284; checked September 29, 2026)

On the Anthropic API, Sonnet 5.5 always has a 1M-token context, with no [1m] suffix and no extra charge. Auto-compact runs at about 967K tokens by default. Through an LLM gateway (with ANTHROPIC_BASE_URL set), the context is treated as 200K tokens, so pick "Sonnet 5.5 (1M context)" (sonnet[1m]) in the model picker.

opusplan, which splits planning to Opus and execution to Sonnet, runs on Opus 5.5 and Sonnet 5.5 respectively on the Anthropic API. How to use it is covered in our opusplan guide. Claude Code itself advances conversations by appending only, so it doesn't run into the history check in Section 5 ③ (per the Opus 5.5 migration guide).

GitHub Copilot

On the same day, September 28, GitHub announced the general availability of Sonnet 5.5 in its changelog. It is available on Copilot Pro, Pro+, Max, Business and Enterprise, and can be selected from the model picker in VS Code, Visual Studio, Copilot CLI, Copilot coding agent, github.com, JetBrains IDEs, Xcode and more. The rollout is gradual, so it may not appear right away. Billing is usage-based at the provider's list price. On Business and Enterprise, administrators decide whether it's available through the model policy in Copilot settings.

10. Migration steps (for API users)

From the migration guide's checklist, here are the items that apply when moving from Sonnet 5, in working order. Claude Code also has /claude-api migrate to help with this (a bundled skill pointed to by the migration guide; it confirms the scope with you before editing).

Source: "Every starting model" and "Migrating to Claude Sonnet 5.5 from Claude Sonnet 5" in Anthropic, "Migrating to Claude Sonnet 5.5", reordered into working order

If you are coming directly from Sonnet 4.6 or earlier, you also need to deal with thinking running even on jobs that didn't specify thinking, the 400s for budgets and for temperature and similar parameters, and about 30% more tokens for the same text. If you use it through Claude Managed Agents, nothing needs to change other than the model name (note in the migration guide).

Summary

Claude Sonnet 5.5 is a release that raised performance substantially while keeping the price unchanged, and in exchange moved its API conventions toward Opus 5.5. In Anthropic's own table it improved on Sonnet 5 in every row and came within a few points of Opus 5.5 in most. On the other hand, disabled, forced tool use, the legacy computer use tool, rewritten history and some advisor pairings now cause 400 errors.

The easiest things to miss are that between_tools, the replacement for turning thinking off, is accepted only at high or below, and the mismatch that default effort is high on the API but medium in Claude Code. On the API, set effort explicitly; in Claude Code, select it with /model sonnet and then check the effort level. Whether it actually got cheaper should be measured with usage, not unit prices.

Finally, benchmark numbers are values measured in that table under those conditions. Anthropic itself writes that Opus 5.5 remains clearly stronger on complex, open-ended work. Start by comparing Sonnet 5.5 at medium and high on your own work.

FAQ

* The figures in this article are based on Anthropic's official announcement, "Introducing Claude Sonnet 5.5" (benchmarks from that page's comparison table and chart descriptions), the official documentation "Models overview," "Claude Sonnet 5.5," "What's new in Claude Sonnet 5.5," "Migrating to Claude Sonnet 5.5," "Pricing," "Thinking," "Effort" and "Prompt caching," Claude Code's "Model configuration" and CHANGELOG, and GitHub's changelog (all checked September 29, 2026). Specifications and prices may change, so confirm the final details in the official documentation.

Related articles: Claude Opus 5.5 release overview, Claude Fable 5.1 breaking changes and migration, Claude pricing comparison.