TL;DR

Claude Sonnet 5 shipped on June 30, 2026 as the default model on Claude’s Free and Pro plans. Reported launch numbers put it at 63.2% on SWE-bench Pro, behind Opus 4.8’s 69.2% and ahead of Sonnet 4.6’s 58.1%, and at 80.4% on Terminal-Bench 2.1, where it beat Opus 4.8. Its $2/$10 per million tokens was sold as an introductory price, but Anthropic made it permanent in August, so the planned jump to $3/$15 never happened. The new tokenizer uses 1.0–1.35× more tokens for the same text, which still leaves it 10–33% cheaper per request than Sonnet 4.6. Then Sonnet 5.5 arrived on September 28 at the same $2/$10 price and scored 70.6% on Terminal-Bench 4.0 to Sonnet 5’s 10.3%. My take: Sonnet 5 was the right default in July. Today it’s a legacy model you keep only while you migrate.

Pricing, model status and the Sonnet 5.5 comparison last verified: October 31, 2026.

What Claude Sonnet 5 Actually Is

Anthropic ships models in three sizes: Haiku for cheap and fast, Sonnet for the middle, Opus for the frontier. Sonnet has always been the workhorse, the one that runs when you don’t think about which model you’re using. Sonnet 5 is the fifth generation of that workhorse, and its launch pitch was that the middle tier had crept close enough to the top tier that the top tier stopped being the obvious choice.

It landed as the default for Free and Pro on claude.ai the day it launched, with access for Max, Team, and Enterprise, plus the API id claude-sonnet-5 on the Claude Platform and inside Claude Code. That default placement counted for more than the benchmarks, because people who never open the model picker get whatever Anthropic sets as the default.

Four months on, its status has changed. The models overview now lists Sonnet 5 under “Legacy models (still available)”, alongside Opus 4.8 and Sonnet 4.6. The current lineup is Fable 5.1, Opus 5.5, Sonnet 5.5 and Haiku 5.5. Legacy here doesn’t mean deprecated: the model deprecations page still shows claude-sonnet-5 as active, with retirement no sooner than June 30, 2027. Pinned production code keeps working, and you have a long runway to migrate.

The Benchmark Breakdown

Here are the launch numbers reported by MarkTechPost, lined up against the two models Sonnet 5 was measured against at the time: its own predecessor and the flagship one rung up. Anthropic’s announcement shows the same comparison as a chart image rather than text, so treat these as reported figures.

BenchmarkSonnet 5Sonnet 4.6Opus 4.8
SWE-bench Pro (agentic coding)63.2%58.1%69.2%
Terminal-Bench 2.180.4%—74.6%
OSWorld-Verified (computer use)81.2%78.5%83.4%
BrowseComp (agentic search)84.7%——
GDPval-AA v2 (knowledge work, Elo)1,618—1,615
FrontierCode38.8%15.1%—

Two rows stand out. On SWE-bench Pro, the 5.1-point jump from Sonnet 4.6 to Sonnet 5 (58.1 to 63.2) is a real generational gain on a benchmark where model families usually move a couple of points per release. FrontierCode more than doubled, from 15.1% to 38.8%. FrontierCode targets hard, long-horizon coding problems that break most models, so a 2.5× jump there was the clearest sign that Sonnet 5 got better at sustained agentic work.

The Terminal-Bench result is the one that made me raise an eyebrow. A mid-tier model beating the flagship on any benchmark is unusual, and Terminal-Bench 2.1 measures the shell-driving, command-running, output-reading loop that agentic coding lives in. Sonnet 5’s 80.4% against Opus 4.8’s 74.6% suggested that for the edit, run tests, read the failure, fix, rerun cycle, the extra brains in Opus didn’t help much. That loop is also the simplest kind of agent to build yourself; our Go agent tutorial builds a minimal one around claude-sonnet-5 for exactly this cycle.

Where Opus 4.8 still won was SWE-bench Pro and OSWorld, both by a handful of points. The GDPval knowledge-work Elo was essentially a tie (1,618 vs 1,615).

One caveat before you lean on any of this table: every number in it is on a suite Anthropic has since moved past. The Sonnet 5.5 announcement reports Terminal-Bench 4.0, FrontierCode 1.1 and OSWorld 2.1 instead, and on those harder versions Sonnet 5 looks much weaker (more on that below).

63.2%
SWE-bench Pro (reported)
$2 / $10
Per 1M tokens, now permanent
1M
Context window
10.3%
Terminal-Bench 4.0 (Sonnet 5.5: 70.6%)

Day-To-Day Behavior

Benchmark suites skip the routine tasks that fill most of a working day, so early coverage of everyday use is the better guide there.

Early coverage reported a self-verification loop: the model runs tests, reads the failures, patches and reruns without being told to. Picture a handler migration from a hand-rolled router to chi. Without that loop, a model writes the change and stops, leaving you to run the suite and paste back the failures. With it, the model writes the change, runs the tests, fixes what broke and reruns until green before it hands back the diff, which removes the manual run-and-paste round trip entirely.

It still had failure modes, and the SWE-bench Pro gap (69.2% vs 63.2%) showed where. On hard, ambiguous bugs that need real backtracking, Opus 4.8 pulled ahead. When Sonnet 5 kept proposing variations of the same wrong fix, the practical move was to escalate that one task to the bigger model. Today that escalation target is Opus 5.5, and the first thing to try is Sonnet 5.5.

The Tokenizer Tax

The tokenizer changes the effective price. Sonnet 5 ships with an updated tokenizer, and Anthropic’s announcement says it produces roughly 1.0 to 1.35× more tokens for the same input text than Sonnet 4.6 did. The pricing docs describe it as the tokenizer introduced with Claude Opus 4.7, at about 30% more tokens for the same text. The multiplier isn’t uniform: plain English lands near the low end, while code, structured data, and non-English text push toward the high end.

When this review first ran, the tokenizer looked like a trap, because the $2/$10 price was only promised through August 31, with $3/$15 to follow. At $3/$15, Sonnet 5 would have matched Sonnet 4.6’s sticker while burning more tokens. That never happened. An August 10 update to the announcement made $2/$10 permanent, and the pricing page now says the scheduled increase “will not occur.”

The real question is whether a 33% lower price per token beats up to 35% more tokens. I ran the numbers for a request that costs 20K input and 2K output tokens on Sonnet 4.6’s tokenizer:

# Effective cost of one request on Sonnet 4.6 vs Sonnet 5, tokenizer included.
# Prices: platform.claude.com/docs/en/about-claude/pricing (checked 2026-10-31).
PRICES = {  # $ per million tokens: (input, output)
    "sonnet-4.6": (3.00, 15.00),
    "sonnet-5": (2.00, 10.00),
}

# A request that costs 20K input + 2K output tokens on Sonnet 4.6's tokenizer.
IN_46, OUT_46 = 20_000, 2_000

def cost(model, inflation=1.0):
    pin, pout = PRICES[model]
    return (IN_46 * inflation * pin + OUT_46 * inflation * pout) / 1e6

base = cost("sonnet-4.6")
print(f"Sonnet 4.6            ${base:.4f}")
for infl in (1.00, 1.15, 1.35):
    c = cost("sonnet-5", infl)
    print(f"Sonnet 5 at {infl:.2f}x tokens ${c:.4f}  ({c / base:.0%} of 4.6)")
# Token inflation at which Sonnet 5 would cost the same as 4.6
print(f"break-even inflation: {3.00 / 2.00:.2f}x")

Running it prints:

Sonnet 4.6            $0.0900
Sonnet 5 at 1.00x tokens $0.0600  (67% of 4.6)
Sonnet 5 at 1.15x tokens $0.0690  (77% of 4.6)
Sonnet 5 at 1.35x tokens $0.0810  (90% of 4.6)
break-even inflation: 1.50x

Even at the worst end of Anthropic’s range, Sonnet 5 costs 90% of what Sonnet 4.6 does for the same text. The tokenizer would need to inflate counts by 1.5× before the price cut disappeared, and Anthropic’s own ceiling is 1.35×. At worst the tax absorbs 23 of the 33 points of discount. The calculation assumes the same number of turns and the same output length per task. A model that finishes in fewer turns, which is the whole selling point of the self-verification loop, does better than this table shows.

Prompt caching is where Sonnet 5 and 5.5 split. Both share the same tokenizer, so the same text produces the same counts, but cache reads cost $0.20 per million on Sonnet 5 and $0.10 on Sonnet 5.5. For agents that re-read a large, stable context every turn, that halves the biggest line on the bill. Trimming that context in the first place helps too; our piece on context engineering covers why agents often do better with less of it.

ModelInput / 1MOutput / 1MCache read / 1MStatus
Sonnet 5$2$10$0.20Legacy, active until at least Jun 30, 2027
Sonnet 5.5$2$10$0.10Current Sonnet, released Sep 28, 2026
Sonnet 4.6$3$15$0.30Legacy, older tokenizer
Opus 5.5$4$20$0.20Current Opus, released Sep 22, 2026
Opus 4.8$5$25$0.50Legacy flagship from this review’s launch

Sonnet 5 vs Sonnet 5.5: Should You Upgrade?

Yes, for nearly everyone. Sonnet 5.5 launched on September 28, 2026 at the same $2/$10 price, with the same tokenizer, the same 1M context window and 128K max output. Anthropic reports it typically needs fewer tokens per task and costs up to 30% less per task than Sonnet 5. The benchmark gap on the new suites is wide:

Benchmark (reported by Anthropic)Sonnet 5.5Sonnet 5Opus 5.5
Terminal-Bench 4.070.6%10.3%66.4% (xhigh)
FrontierCode 1.1 (Main)46.2% (max effort)42.4%54.4%
CursorBench 4.055.5%34.1%57.8%
OSWorld 2.1 (partial)80.1%57.0%81.8%
GDPval-AA v2.1 (Elo)1,8441,4491,846
Humanity’s Last Exam (with tools)64.5%54.9%67.7%

The Terminal-Bench row is the striking one. Sonnet 5 went from beating Opus 4.8 on Terminal-Bench 2.1 to scoring 10.3% on version 4.0, so the harder suite exposes long-horizon terminal work that the July model couldn’t finish. Sonnet 5.5 scores 70.6% there, slightly above Opus 5.5’s 66.4%. That repeats the July pattern, where the Sonnet tier kept pace with the Opus tier on the terminal loop, only now the Sonnet doing it is 5.5.

Upgrading takes more than changing the model id. Anthropic’s What’s new in Sonnet 5.5 lists five breaking changes for code already running on Sonnet 5:

  1. thinking: {"type": "disabled"} returns a 400 error. The lowest setting is now between_tools, accepted at low, medium and high effort.
  2. Forced tool use is gone. tool_choice of any or a named tool returns a 400; use auto with strict tool use or structured outputs.
  3. Thinking blocks are tied to the model and the conversation, so editing earlier history and replaying a block can fail. Keep conversations append-only.
  4. On the Claude API, the old computer_20251124 computer use tool is rejected in favor of computer_toolset_20260801.
  5. The advisor tool no longer accepts Opus 4.8, Opus 4.7, Sonnet 5 or Haiku 5.5 as advisors for a Sonnet 5.5 executor.

Two quieter changes catch people too. Text the model writes between tool calls now comes back in thinking blocks, so a UI that streams those notes goes silent until you set a display value. Effort levels are recalibrated, so a setting tuned on Sonnet 5 won’t produce the same amount of thinking. And the model page notes that setting temperature, top_p or top_k on Sonnet 5.5 returns a 400.

A minimal migrated request looks like this:

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY

message = client.messages.create(
    model="claude-sonnet-5-5",          # was "claude-sonnet-5"
    max_tokens=4096,
    thinking={"type": "between_tools"},  # was {"type": "disabled"}
    tools=tools,
    tool_choice={"type": "auto"},        # "any" / named "tool" now return 400
    messages=messages,                   # append-only: don't edit earlier turns
)

I haven’t run this snippet here, because it needs an API key and a live tool loop. The field values come straight from Anthropic’s migration notes.

When To Use Sonnet 5 vs Opus

The routing rule from July still holds; only the model names changed. Send everything to the Sonnet tier by default, and today that means Sonnet 5.5. Escalate to Opus 5.5 ($4/$20) when a task is hard enough that a wrong answer is expensive: a subtle concurrency bug, an ambiguous spec, a refactor where backtracking pays off. Fable 5.2 sits above both at $8/$40 for the longest autonomous runs, the slot Fable 5 held when this review first ran. Keep Haiku 5.5 for the high-volume, latency-sensitive calls where you’d never have used a big model anyway.

The price gap between tiers has also shrunk. Opus 4.8 was 2.5× the Sonnet 5 price. Opus 5.5 is exactly 2×, and Anthropic’s models overview now tells new users to start with Opus 5.5 for most workloads. Claude Code made the same call: per the model configuration docs, the default setting resolves to Opus 5.5 on Pro, Max, Team, Enterprise and the API, and Pro and Team Standard defaulted to Sonnet 5 only before Claude Code v2.1.280. If you’re cost-sensitive, that default is worth overriding with the sonnet alias for routine work.

Sonnet 5 still makes sense in two cases: as a pinned production model you haven’t migrated yet, or when your code depends on forced tool use and you need time to rework it. Both are reasons to put the migration on the calendar.

If you’re weighing this against non-Anthropic options, the picture is more crowded than it was in July. GLM-5.2 undercuts everyone on price with open weights, and the GPT-5.5 section of our coding-model hub covers how OpenAI’s line trades blows on general tasks. For an older but still useful picture of the tradeoffs, our GPT vs Claude vs Gemini coding comparison holds up on the general shape, even if the version numbers have moved twice since.

How To Switch Models

On claude.ai, the model picker decides. On the API, you point at a model id. Via the Python SDK from the Anthropic console">Anthropic console, pinning the legacy model still works exactly as it did at launch:

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY

message = client.messages.create(
    model="claude-sonnet-5",  # legacy, active until at least 2027-06-30
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Refactor this Go HTTP handler to use chi router "
                       "and update the table-driven tests.",
        }
    ],
)
print(message.content[0].text)

In Claude Code, the sonnet alias now points at Sonnet 5.5. Pin the full id if you need the older model for a comparison run:

# Current Sonnet (5.5) for this session
claude --model sonnet

# Pin legacy Sonnet 5 explicitly
claude --model claude-sonnet-5

# Or make a choice sticky in your shell profile
export ANTHROPIC_MODEL="claude-sonnet-5-5"

If you run Claude Code in scripted pipelines, our Claude Code workflows tutorial shows where the model setting goes in headless runs. In a coding IDE like Cursor, the same ids work.

To measure your own tokenizer multiplier instead of guessing within the 1.0–1.35× range, count the same prompt on Sonnet 4.6 and Sonnet 5:

import anthropic

client = anthropic.Anthropic()
text = open("prompt.txt").read()

for model in ("claude-sonnet-4-6", "claude-sonnet-5"):
    resp = client.messages.count_tokens(
        model=model,
        messages=[{"role": "user", "content": text}],
    )
    print(model, resp.input_tokens)

There’s no point repeating the count against claude-sonnet-5-5. Anthropic’s docs say it uses Sonnet 5’s tokenizer, so the same text produces the same token count.

Who Should Use It, Who Should Skip

Keep Sonnet 5 for now if:

  • You have it pinned in production and no migration slot yet. It stays active until at least June 30, 2027, at the same $2/$10.
  • Your code relies on forced tool use (tool_choice of any or a named tool) or on thinking: disabled, both of which Sonnet 5.5 rejects. Fix those first, then switch.
  • Your app streams the model’s notes between tool calls and you haven’t handled the new thinking block shape yet.

Move to Sonnet 5.5 if:

  • You’re starting anything new. Same price, same tokenizer, half the cache-read cost and far better scores on the current benchmark suites.
  • You run agents with long, cache-heavy contexts. The $0.10 cache read is the single biggest saving between the two.
  • You were still paying for Opus out of habit on routine work. Check our Claude Code Max vs Pro breakdown before deciding how much Anthropic compute to buy.

FAQ

How much does Claude Sonnet 5 cost?

$2 per million input tokens and $10 per million output tokens. That was announced as an introductory price through August 31, 2026, but Anthropic made it permanent on August 10, and the planned move to $3/$15 was cancelled. Cache reads cost $0.20 per million. Factor in the tokenizer, which uses 1.0–1.35× more tokens than Sonnet 4.6 for the same text.

Is Claude Sonnet 5.5 better than Sonnet 5?

On every benchmark Anthropic published for both, yes. Sonnet 5.5 scores 70.6% on Terminal-Bench 4.0 against Sonnet 5’s 10.3%, 80.1% on OSWorld 2.1 against 57.0%, and 55.5% on CursorBench 4.0 against 34.1%. It costs the same $2/$10, uses the same tokenizer, and charges half as much for cache reads. The catch is five breaking API changes, mostly around thinking settings and forced tool use.

Claude Sonnet 5 vs Opus 5.5: which should I use?

Neither should be your default for new work. Sonnet 5.5 replaces Sonnet 5 at the same price. Between Sonnet 5.5 and Opus 5.5, use Sonnet for routine coding and agent loops, and escalate to Opus 5.5 ($4/$20) for the hardest tasks. Opus 5.5 leads on FrontierCode 1.1 (54.4% vs Sonnet 5.5’s 46.2% at max effort), while Sonnet 5.5 edges it on Terminal-Bench 4.0.

Is Claude Sonnet 5 good for coding?

It was the strongest mid-tier coding model when it launched, with a reported 63.2% on SWE-bench Pro and a Terminal-Bench 2.1 score above Opus 4.8. It still works, and its agentic follow-through (running tests and fixing its own code) holds up on routine tasks. But on Anthropic’s newer suites it trails Sonnet 5.5 by a wide margin, so for new coding work use 5.5.

What is Claude Sonnet 5’s context window?

1 million tokens. Anthropic’s pricing docs say every model from the 4.6 generation on, Sonnet 5 included, gets the full 1M window at standard pricing, the same as Sonnet 5.5. On the current tokenizer, 1M tokens is roughly 555,000 words.

When was Claude Sonnet 5 released?

June 30, 2026. It became the default model on the Free and Pro plans the same day. Sonnet 5.5 followed on September 28, 2026.

Sources

Bottom Line

Sonnet 5 held up against its launch claims. It brought the mid tier within a few points of the flagship on the July benchmarks, beat it on the terminal loop, and the price cut that was supposed to be temporary turned out to be permanent. My one warning in July, the tokenizer tax, turned out smaller than it looked, because a 33% lower price absorbs up to 35% more tokens with room to spare.

The recommendation changed on September 28. Sonnet 5.5 costs the same, counts tokens the same way, halves the cache-read price, and scores roughly seven times higher on Terminal-Bench 4.0. If you’re choosing a Sonnet today, pick 5.5. If Sonnet 5 is pinned in your production code, it’s safe until mid-2027, so budget an afternoon for the five breaking changes and move.