Claude Sonnet 5.5 vs Sonnet 5: Cost by Effort and What Breaks

Claude Sonnet 5.5 (claude-sonnet-5-5) is the Sonnet model Anthropic released on September 28, 2026, as the successor to Sonnet 5. It bills exactly what Sonnet 5 does: $2 per million input tokens and $10 per million output tokens, with the same cache and batch rates. It also uses the same tokenizer, so the same text counts the same tokens. What moves your bill is how many tokens it spends to finish a task, and that depends on the effort level you run.

On the Artificial Analysis (AA) Intelligence Index, as of October 5, 2026, Sonnet 5.5 costs less per task than Sonnet 5 at low, medium, high, and xhigh effort and scores higher at every level. At max, it costs about 51% more. That's how Anthropic's "costs up to 30% less for most work" and AA's "~50% higher than Sonnet 5's Cost per Task" can both be true: AA's headline compares the two models at max.

Switching takes more than a model ID change. Five changes can return 400 errors on code that works on Sonnet 5, including thinking: {"type": "disabled"} and forced tool_choice. Sonnet 5 stays available as a legacy model until at least June 30, 2027, so you have time to fix them first. If you're still on Sonnet 4.5, your clock is shorter: it retires from the Claude API on November 30, 2026.

Sonnet 5.5 vs Sonnet 5 specs: same price and tokenizer, newer cutoff

Sonnet 5.5 is still a Sonnet-class model: same price tier, same context window, same output limit. The differences that matter in practice are the knowledge cutoff, how you turn thinking off, and the defaults in Claude Code and the Claude apps.

Prices and lifecycle dates come from the Claude API pricing page and Anthropic's model deprecations page; the rest is from What's new in Claude Sonnet 5.5 in the Claude Platform docs. Batch processing is 50% off for both models. For why Sonnet 5 ended up at $2/$10 after a planned increase, see Claude Sonnet 5 Price Increase Canceled: Current Rates and Billing Math.

Sonnet 5.5 is available on the Claude API, Amazon Bedrock, Claude Platform on AWS, Google Cloud, and Microsoft Foundry. Cloud providers set their own lifecycle dates, so check your provider's model list if you aren't on the Claude API.

Is Sonnet 5.5 cheaper than Sonnet 5? Per task, yes, except at max

Per token, no: the rates are identical. Per task, Sonnet 5.5 costs less at every effort level except max, because below max it usually finishes with fewer output tokens. The table below uses AA's Intelligence Index v4.3.2, a mix of 10 evaluations, as published on Artificial Analysis's Claude Sonnet 5.5 model page as of October 5, 2026. Cost per task is what AA spent to run one index task. Scores are rounded to whole numbers.

Cost change is (Sonnet 5.5 cost ÷ Sonnet 5 cost) − 1, calculated from AA's figures. For max, that's 7.67 ÷ 5.09 − 1 = +51%. For high, 1.12 ÷ 1.79 − 1 = −37%.

The max row is where Sonnet 5.5's token appetite shows. AA measured about 197,400 output tokens per task at max, against 117,800 for Sonnet 5, roughly 68% more. At high, it was the other way around: 37,300 for Sonnet 5.5 against 44,300 for Sonnet 5. At xhigh, Sonnet 5.5 already writes more output (74,800 vs 65,400 tokens), and the two models cost about the same per task.

So the two headlines measure different things:

• Anthropic's "up to 30% less per task" comes from Anthropic's Claude Sonnet 5.5 announcement. It's a vendor maximum from Anthropic's own tests, stated "for most work." It doesn't promise savings at every setting.
• AA's "~50% higher" comes from Artificial Analysis's Sonnet 5.5 launch analysis on September 28, 2026, and compares both models at max, the one setting where Sonnet 5.5 spends far more tokens.

The bigger saving comes from dropping a level. On AA's index, Sonnet 5.5 at low (36, $0.42) outscored Sonnet 5 at xhigh (34, $2.87) at about one-seventh the cost. Sonnet 5.5 at medium (41, $0.59) outscored Sonnet 5 at max (38, $5.09) at about one-ninth the cost. Anthropic describes the same pattern on several of its own benchmarks: Sonnet 5.5 at Low or Medium effort beats Sonnet 5's best score "for about a tenth of the cost per task."

A real workload shows a similar direction. In CodeRabbit's Sonnet 5.5 code-review test, the Claude calls behind one review cost about 60% less on Sonnet 5.5 ($0.46–0.47 vs $1.16 at list prices) and finished in about half the wall-clock time. That run covered 13 hard known-bug cases, a sample CodeRabbit itself calls small.

Speed splits the same way as cost. AA's time per task drops at most levels, for example from 375 to 238 seconds at high, but rises at max, from 852 to 968 seconds. Anthropic reports that Sonnet 5.5 generates output 30%+ faster than Sonnet 5.

How much better is Sonnet 5.5? 12 to 18 index points over Sonnet 5

On AA's index, Sonnet 5.5 scores 12 points higher than Sonnet 5 at low and 18 higher at max. At max, its score of 56 put it second on AA's index at launch, two points behind Opus 5.5 at max.

Anthropic's launch table shows larger jumps on agentic work. These are vendor-run evaluations, mostly at the highest effort:

Read the Terminal-Bench row with care. Sonnet 5's 10.3% baseline is unusually low: AA's own Terminal-Bench 4.0 runs measured 14.1% for Sonnet 5 and 63.6% for Sonnet 5.5, both at max. The gap is still large, just not 60 points.

CodeRabbit's review test adds a third-party view on bug finding. Sonnet 5.5 caught 6 of 13 known bugs against 4 for Sonnet 5, at nearly the same actionable precision (41.2% vs 40.0%). Four of its catches were bugs Sonnet 5 missed, and it missed two that Sonnet 5 caught, so it's a different set of misses as much as more catches.

It's still a Sonnet. Anthropic says Opus 5.5 "remains clearly stronger at complex, open-ended work requiring sustained judgment," and AA measured lower factual accuracy for Sonnet 5.5 than Opus 5.5 on AA-Omniscience (54% vs 66%). Opus 5.5 lists at $4/$20 per million tokens, twice Sonnet's rates.

Which Sonnet 5.5 effort level replaces your Sonnet 5 setting

Don't copy your Sonnet 5 setting. Anthropic recalibrated the levels, so high on Sonnet 5.5 doesn't produce the same amount of thinking as high on Sonnet 5, and its migration guide tells you to re-run your effort sweep. Anthropic's effort parameter docs give these starting points for Sonnet 5.5:

• Most work: start at high, the Claude API default.
• Agentic coding and multistep tool use: start at medium for well-specified tasks, and move to high for harder or longer ones.
• Chat and other latency-sensitive work: start at medium or low.
• xhigh and max: use them only where your evals show a quality gain.

AA's data gives you the other end of the sweep: the lowest Sonnet 5.5 level that already matched your old Sonnet 5 setting on its index.

Percentages use the same formula as above, for example 0.42 ÷ 1.79 − 1 = −77%.

The rule that follows: sweep between that floor and Anthropic's starting point for your workload, and keep the lowest level that passes your own evals. An index score averages 10 evaluations, and your workload may lean hard on one of them, so the floor tells you where to start testing, not where to stop.

Treat max as a separate decision. On AA's index, Sonnet 5.5 at max adds 9 points over high (56 vs 47) at about 6.8 times the cost per task ($7.67 vs $1.12). If your Sonnet 5 job ran at max because nothing lower was good enough, try high on Sonnet 5.5 before paying for max.

If you ran Sonnet 5 with thinking off, the choice narrows. between_tools, the Sonnet 5.5 replacement for disabled, works only at low, medium, and high. A thinking-off setup at xhigh or max has to pick one: drop to high and keep up-front thinking off, or stay at xhigh or max with adaptive thinking on.

Five changes that return errors after switching to claude-sonnet-5-5

Anthropic lists five breaking changes for code already running on Sonnet 5. Check each row against your integration before you change the model ID:

If you use Claude Code, the bundled Claude API skill can apply the model ID swap and the breaking parameter changes for you. Run /claude-api migrate this project to claude-sonnet-5-5; it asks you to confirm the scope before editing files and ends with a checklist of items to verify by hand. Anthropic's Sonnet 5.5 migration guide has before-and-after requests in every SDK language. The two you're most likely to need are below in Python.

Thinking off: replace "disabled" with "between_tools"

On Sonnet 5.5, disabled fails with this message:

To turn thinking off on this model, send "thinking": {"type": "between_tools"} instead of {"type": "disabled"}. The model does not think before responding. The short updates it writes between tool calls come back as thinking blocks.

A Sonnet 5 request that turned thinking off at xhigh:

client.messages.create(
    model="claude-sonnet-5",
    max_tokens=16000,
    thinking={"type": "disabled"},
    output_config={"effort": "xhigh"},
    messages=[{"role": "user", "content": "..."}],
)

The Sonnet 5.5 version keeps thinking off, so effort has to come down to high:

client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=16000,
    thinking={"type": "between_tools"},
    output_config={"effort": "high"},
    messages=[{"role": "user", "content": "..."}],
)

To stay at xhigh or max instead, remove the thinking field (or send {"type": "adaptive"}) and accept up-front thinking. between_tools takes no other field: sending display, budget_tokens, or block_binding with it returns a 400 error. With it, you also can't change effort mid-conversation. Without tools, the response is text only, the same as disabled on Sonnet 5.

Forced tool use: tool_choice "any" and "tool" are rejected

Sonnet 5 code that forced a tool call:

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?"}],
)

On Sonnet 5.5, let the model choose and make the tool strict so its input matches the schema:

client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=1024,
    # strict tool use: every call matches the tool's input_schema
    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.",
        }
    ],
)

With auto, the model can answer without calling the tool, so the prompt has to say when the tool applies. Strict tool use needs additionalProperties: false on every object and allows at most 20 strict tools per request. On Amazon Bedrock, structured outputs (which include strict tool use) aren't available for Sonnet 5.5, so send auto without strict and validate the tool input in your own code.

Thinking blocks, computer use, and advisor pairings

Thinking blocks now record which model and which conversation produced them. Moving a conversation from Sonnet 5 onto Sonnet 5.5 keeps its reasoning, because Sonnet 5.5 reads Sonnet 5's blocks. Moving from Sonnet 5.5 up to Opus 5.5 keeps it too, on the Claude API and Google Cloud. Any other move away from Sonnet 5.5 drops the blocks: the request still succeeds, and dropped blocks aren't billed. Sonnet 5.5 thinking blocks also work only in the account that produced them or a linked account.

The edit check is the one that throws errors. If anything before a Sonnet 5.5 thinking block changes (the system prompt, the tools, or an earlier message) and you replay the block, newer accounts get a 400. To drop the affected blocks instead of failing, send the thinking-binding-controls-2026-08-01 beta header and set thinking.block_binding.prefix_mismatch_behavior to "drop_block"; this works only with adaptive thinking.

For computer use on the Claude API or Google Cloud, drop the beta header, replace the tools entry with {"type": "computer_toolset_20260801"}, and update your agent loop for member tool_use blocks, batched actions, and toolset_name on results. If you also send fine-grained-tool-streaming-2025-05-14, remove it; next to a toolset entry it returns a 400.

For the advisor tool, every advisor Sonnet 5.5 accepts returns its advice encrypted as an advisor_redacted_result block. If your code reads the advice text, that part stops working even after you pick a supported advisor.

Changes with no error: quiet tool loops, new refusals, cheaper caching

Some differences change the response without failing a request. They're easy to miss in testing because nothing returns a 4xx.

Text between tool calls moves into thinking blocks. On Sonnet 5, everything the model wrote between tool calls came back as text. On Sonnet 5.5, notes longer than a sentence or two come back as progress-update thinking blocks, which are empty at the default display: "omitted". An app that streams those notes to users goes quiet between tool calls. With adaptive thinking, set thinking.display to "updates" (with the thinking-display-updates-2026-08-18 beta header) for the updates alone, or to "summarized" for updates mixed with reasoning. Render each non-empty thinking block before the tool_use block that follows it. With between_tools, the text comes back without any display setting.

More requests can end in a refusal. Sonnet 5.5 is the first Sonnet with cyber safeguards and reasoning-extraction classifiers. A declined request returns HTTP 200 with stop_reason: "refusal" and a stop_details category: cyber, bio, frontier_llm, reasoning_extraction, or general_harms. Benign work can trigger general_harms. Server-side fallback (fallbacks: "default", beta, Claude API only) retries cyber and frontier_llm declines on Sonnet 5; it doesn't retry the other three. Refusals count against your rate limits either way, and whether one is billed depends on its category. If your code only checks for errors, add a check for this stop reason.

Smaller prompts can be cached. The minimum cacheable prompt drops to 512 tokens from 1,024, so prompts in between now get cache-read pricing.

New controls you can use. Sonnet 5.5 supports per-message effort (beta), mid-conversation system messages, and mid-conversation tool changes (beta), none of which Sonnet 5 offers. Mid-conversation system messages are also the clean way to change instructions without tripping the thinking-block edit check.

Using Sonnet 5.5 in Claude Code: version, alias, effort, and /status

Claude Code needs version 2.1.284 or later for Sonnet 5.5. Here's the switch, in order:

1. Run claude update. On older versions, requests for Sonnet 5.5 fail.
2. Switch with /model claude-sonnet-5-5 (or /model sonnet on the Anthropic API). Press Enter in the picker to save it as your default, or s for this session only. To start a session on it, use claude --model claude-sonnet-5-5 or set ANTHROPIC_MODEL.
3. Run /status to confirm which model is running.
4. Set effort on purpose. Sonnet 5.5 starts at medium in Claude Code, where Sonnet 5 started at high. A top-level effortLevel you saved in user settings for older models doesn't carry over; pick a level with /effort (for example /effort high), --effort, or CLAUDE_CODE_EFFORT_LEVEL.

Switch at the start of a session when you can. Changing models mid-session invalidates the prompt cache, so the next request re-reads the whole conversation at uncached rates.

The sonnet alias doesn't mean Sonnet 5.5 everywhere. Per Claude Code model configuration docs, it resolves by provider:

On those providers, select Sonnet 5.5 by its full model ID, or pin it with ANTHROPIC_DEFAULT_SONNET_MODEL. The pin has one side effect on cyber fallback. When a Sonnet 5.5 request is flagged for cybersecurity, Claude Code re-runs it on Sonnet 5 and the session stays on Sonnet 5 until you run /model again. On Bedrock, Google Cloud, and Foundry, that re-run goes to the model set in ANTHROPIC_DEFAULT_SONNET_MODEL, or to a Sonnet 5 entry in your provider's model list if that variable isn't set. A pin that names Sonnet 5.5 itself leaves the refusal standing. Fallback on those providers also needs an Opus target: ANTHROPIC_DEFAULT_OPUS_MODEL or an Opus 4.8 entry. Biology-flagged requests on Sonnet 5.5 end in a refusal on every provider, because there's no biology fallback model.

In the Claude apps, Sonnet 5.5 also runs at Medium effort by default, while the Claude Platform API defaults to High.

Should you stay on Sonnet 5 for now? When waiting makes sense

You can. Sonnet 5 is a legacy model, not a deprecated one: there's no deprecation notice, it's still available, and its retirement is not sooner than June 30, 2027. Anthropic suggests you consider moving to Sonnet 5.5 but sets no deadline.

Waiting makes sense when:

• Your code forces tool calls and you haven't moved to auto with strict tools or structured outputs, especially on Bedrock, where structured outputs aren't available for Sonnet 5.5.
• Your production job runs at max and cost per task is the number you're held to. On AA's index, Sonnet 5.5 at max costs about 51% more per task. Testing Sonnet 5.5 at high is the alternative to staying.
• Your app edits conversation history, such as rewriting the system prompt each turn or trimming old messages, and your account was created on or after August 31, 2026.
• Your UI streams the model's notes between tool calls and you haven't added display handling yet.
• Your advisor-tool code reads the advice text, which Sonnet 5.5 always encrypts.
• Your work is security research that regularly trips cyber classifiers. Flagged requests fall back to Sonnet 5 anyway.

For chat, well-scoped coding, documents, and most agent work, none of these apply, and the data favors switching and testing one effort level lower.

Still on Sonnet 4.5? The November 30, 2026 retirement

On September 30, 2026, Anthropic deprecated claude-sonnet-4-5-20250929. It retires from the Claude API on November 30, 2026, and the recommended replacement is claude-sonnet-5-5. Sonnet 4.6 isn't affected; its retirement is not sooner than February 17, 2027. Amazon Bedrock, Google Cloud, and Microsoft Foundry set their own dates.

Moving from Sonnet 4.5 means every Sonnet 5 change above plus a longer list. The items most likely to break or change your bill:

• Thinking now runs by default. Sonnet 4.5 ran without it. Read content blocks by type instead of content[0].text, pass thinking blocks back unchanged in tool loops, and revisit max_tokens, which covers thinking plus text.
• Non-default temperature, top_p, and top_k return 400 errors. Remove them.
• Assistant prefill returns a 400: This model does not support assistant message prefill. The conversation must end with a user message.
• The same text costs about 30% more tokens than on Sonnet 4.5's tokenizer, and images now go up to 2,576 pixels, so a 2000×1500 image uses about 2.5 times as many tokens. Re-baseline cost before you compare bills.
• Set output_config.effort explicitly, move output_format to output_config.format, remove interleaved-thinking-2025-05-14 and any context-window beta header, and replace fine-grained-tool-streaming-2025-05-14 with eager_input_streaming.

The migration guide's "Migration checklist by starting model" lists every item for Sonnet 4.5.

Claude Sonnet 5.5 FAQ

Is Claude Sonnet 5.5 free in the Claude app?

As of September 29, 2026, Claude's plan comparison on claude.com lists Sonnet as available on the Free plan and Opus as paid-only, without naming versions. Sonnet 5.5 is the current Sonnet, so that's most likely the model Free users get, but the table doesn't say so directly. In the apps, Sonnet 5.5 runs at Medium effort by default. Through the API, it bills $2/$10 per million tokens.

Is Sonnet 5.5 as good as Opus 5.5?

Not for the hardest work. At max, AA puts Sonnet 5.5 two index points behind Opus 5.5, but Anthropic says Opus 5.5 remains clearly stronger at open-ended work that needs sustained judgment, and Sonnet 5.5 trails on factual accuracy. Sonnet 5.5 costs half as much per token ($2/$10 vs $4/$20).

Is Claude Sonnet 5 deprecated?

No. Anthropic lists Sonnet 5 as legacy and still available, with retirement not sooner than June 30, 2027. The model being retired soon is Sonnet 4.5, on November 30, 2026.

Does Sonnet 5.5 use more tokens than Sonnet 5 for the same text?

Not for input. The tokenizer is the same, so the same text produces the same token count. Output is different: it depends on effort. On AA's index, Sonnet 5.5 wrote fewer output tokens per task than Sonnet 5 at low, medium, and high, and more at xhigh and max.

How does Sonnet 5.5 compare with GPT-6 Astra?

Sonnet 5.5 costs about one-fifth as much per token, but on AA's index it beats GPT-6 Astra only at max, where each task costs more. The per-effort breakdown is in Claude Sonnet 5.5 vs GPT-6 Astra: When the Cheaper Model Wins.