Claude Code Opus vs Sonnet: what each model actually costs you

Sonnet 5 now prices out at 0.4x Opus per token, not the 0.6x this site measured back in June, and switching between them mid-session can still cost you more than staying put. The price gap is real and it's bigger than it used to be - Sonnet 5's introductory $2-per-million-token input rate just became permanent, per Anthropic's own pricing page. What it doesn't do is make a per-turn model flip free money: Claude Code's prompt cache is model-specific, so switching mid-session forces a full-price rebuild of everything you'd already paid the discounted cache-read rate for. The two things that actually bank the savings without touching that cache: pinning cheap-model subagents for mechanical work, and opusplan's plan-then-execute split.

What Opus 5 actually costs you against Sonnet 5, right now

Every Claude model bills five separate rates, and the two you're actually choosing between here are Opus 5 and Sonnet 5 - not the Haiku tier, not a legacy Opus deployment. Pulled straight from Anthropic's pricing page today:

| Rate | Opus 5 | Sonnet 5 | Ratio | | --- | ---: | ---: | ---: | | Base input | $5 | $2 | 0.4x | | Cache write (5m) | $6.25 | $2.50 | 0.4x | | Cache write (1h) | $10 | $4 | 0.4x | | Cache read | $0.50 | $0.20 | 0.4x | | Output | $25 | $10 | 0.4x |

Every axis scales by the same 0.4x - Sonnet isn't just cheaper on the sticker price, it's cheaper on all five rates at once, the same finding the per-token rate breakdown makes for a single model's own five rates. The note on Anthropic's own pricing docs is worth reading directly: Sonnet 5 launched with $2-input/$10-output as "introductory pricing through August 31, 2026," and the previously scheduled increase to $3/$15 on September 1 will not occur - that $2/$10 rate is now the standard, permanent price.

That's why three different sources will tell you three different "Opus costs Nx Sonnet" numbers, and all three are technically correct for the pair of models they're actually comparing:

If you're seeing "5x" quoted somewhere, that's almost always legacy Opus 4.1 pricing ($15/$75, still billed that way on Bedrock and Google Cloud even though it's retired everywhere else) against an older Sonnet generation, not current models. This site's own June estimate landed on 1.67x because Sonnet 4.6 was still at $3 input when that analysis ran. Today's real number, Opus 5 against Sonnet 5, is 2.5x - wider than June, narrower than the 5x still floating around.

Why a per-turn switch doesn't bank the savings the price gap promises

A 2.5x per-token gap sounds like an obvious lever: route the easy turns to Sonnet, keep the hard ones on Opus, save money on every turn that moves. The problem is what "moves" actually costs. Prompt caching is the only reason a multi-turn session stays cheap - it lets a turn re-bill everything already sent at 0.1x instead of full price - and that cache belongs to whichever model wrote it. Point the next turn at a different model and there's nothing to read: Claude Code has to rebuild the cache at full write price before it can bill anything at the cheap rate again.

This site modeled exactly that tradeoff on 904 real sessions (19,350 deduped API calls) back in June, and the honest number is worse than it looks:

The 12.8% figure is what you'd calculate if you only looked at the price difference and assumed the cache rebuilds for free. It doesn't. Priced honestly - counting the full-rate cache-write turn a switch forces - a naive per-turn flip comes out -122%, meaning it costs more than twice what staying on one model the whole session would have. That analysis ran at Sonnet 4.6's pricing, before the September rate freeze above; Sonnet 5's rates have since dropped further, which changes the exact dollar figures but not the mechanism causing the loss - a model switch always forces an uncached rebuild, regardless of which price schedule is in effect that week.

Here's the same shape on one concrete example instead of a corpus average, using Anthropic's own published sample /usage line - 1.2k input, 5.3k output, 940k cache read, 50k cache write - priced at both models' current rates:

$ node -e '
const opus5 = { in: 5, write5m: 6.25, read: 0.50, out: 25 };
const sonnet5 = { in: 2, write5m: 2.50, read: 0.20, out: 10 };
const s = { input: 1200, output: 5300, cacheRead: 940000, cacheWrite: 50000 };
const cost = r => (s.input*r.in + s.output*r.out + s.cacheWrite*r.write5m + s.cacheRead*r.read) / 1e6;
console.log("Opus 5:  $" + cost(opus5).toFixed(3));
console.log("Sonnet 5: $" + cost(sonnet5).toFixed(3));
'
Opus 5:  $0.921
Sonnet 5: $0.368

Same session shape, $0.553 apart, a 2.5x gap end to end - matching the rate ratio exactly, because every one of the five rates moved together. That's the number worth banking. It's also the number you only get to keep if the whole session stays on one model; split it across a mid-session flip and part of that $0.921-to-$0.368 range gets spent twice, once on the switch's cache rebuild.

The two levers that are actually cache-safe

None of this rules out using Sonnet's price advantage - it rules out flipping the main thread's model turn by turn. Two mechanisms sidestep the cache problem entirely, because neither one touches the cache your main session already built:

A subagent starts a fresh, isolated context and pays its own cache from scratch regardless of which model the parent is running - so pinning it to Sonnet or Haiku never invalidates anything on the Opus side. opusplan works differently: it switches on permission mode, not on a per-turn guess, so it's Opus for the reasoning-heavy plan phase and Sonnet once you're executing an approved plan - the exact split plan mode's own cost breakdown covers from the other direction. Both are documented, no-proxy mechanisms; neither is a silent auto-router guessing at difficulty mid-turn. For the delegation math behind when a subagent is worth its fixed overhead in the first place, when Claude Code subagents actually save tokens walks through the break-even.

How much would pinning actually save on your own mix?

npx usagecut apply installs exactly the three subagents above under ~/.claude/agents/, pinned to Sonnet and Haiku, with Opus still ratifying every diff before it lands. The honest savings envelope for that lever, same as the code installing it states plainly: single digits up to roughly 10-15% of total spend, concentrated in delegation-heavy use, and largest for anyone still paying legacy Opus rates rather than Opus 5's current price. That's a real range, not a headline percentage - it depends entirely on how much of your own work is genuinely mechanical enough to hand off.

To see where your own sessions land before installing anything, the Opus vs Sonnet cost calculator prices the real gap for a usage pattern you set and estimates what pinning the Sonnet-safe turns would save, and the free scan reads your actual transcripts instead of an assumed pattern.

When staying on Opus the whole way through is correct

Every downgrade decision - subagent or opusplan - runs the same AND-gate the model picker wizard walks through by hand: the work has to be plan-approved or cleanly delegatable, single-file or mechanically uniform, describable in one sentence with no caveats, nowhere near auth/crypto/payments/migrations, and not a retry of something Sonnet already got wrong. Answering "not sure" on any one of those is supposed to keep the whole task on Opus - a wrong downgrade risks poisoning the rest of a session, so ambiguity resolves to the more expensive, safer model by design, not the cheaper one.

That AND-gate is conservative on purpose. Novel architecture or design tradeoffs, ambiguous debugging across a race condition or state machine, cross-file reasoning over five or more files, and anything in a long session past 40-50 turns where coherence starts to degrade - all of that stays on Opus even though the price gap would look tempting.

FAQ

• Is Sonnet 5 really 0.4x the price of Opus 5? Yes, on every one of the five billed rates - input, both cache-write tiers, cache read, and output - per Anthropic's currently published pricing. Sonnet 5's $2/$10 input/output rate, originally introductory, is now the permanent standard price.
• Why do some sites say Opus costs 5x Sonnet? They're almost always comparing legacy Opus 4.1 pricing ($15/$75, still billed that way on Bedrock and Google Cloud) against an older Sonnet generation, not current Opus 5 and Sonnet 5. The current-model gap is 2.5x.
• Does switching from Opus to Sonnet mid-session actually save money? Not reliably. Claude Code's prompt cache is model-specific, so a switch forces an uncached rebuild of your context at full price. Modeled on this site's own session history, naive per-turn switching loses money once that penalty is counted, even though the raw per-token price gap looks like free savings.
• What's the difference between subagent pinning and opusplan? A subagent runs in its own separate cache, so it's the answer for delegating a bounded, well-scoped step. opusplan switches automatically on permission mode - Opus while planning, Sonnet once you're executing an approved plan - with no extra config and no per-turn guessing.
• Can Claude Code just auto-switch models for me based on difficulty? Not transparently. No Claude Code hook can set the next turn's model - the only way to rewrite it per turn is intercepting the API call with a proxy, which this project deliberately doesn't build, and which would lose money anyway for the cache reason above.
• Is there a free way to see what pinning would save me specifically? The Opus vs Sonnet cost calculator prices the gap for a usage pattern you enter, and npx usagecut reads your real session transcripts to show your own number instead of an average.

Every rate above came straight from Anthropic's currently published pricing, not a memorized figure - worth re-checking directly if you're reading this after August 31, 2026, since that's when Sonnet 5's now-permanent rate was originally scheduled to change. The free UsageCut scan reads your own Claude Code session history and shows exactly what your real Opus/Sonnet mix is costing you before you decide what to pin.

Made by Neo

UsageCut by ClockedCode - not affiliated with Anthropic. The figures on this page are measured on real Claude Code sessions and labeled measured or estimated where it matters.