Claude Code: API or subscription? Do the math on your real usage first

Run twenty sessions this month on API billing and the bill matches exactly what you used - run zero and it's $0.00. Run the same twenty sessions on a $100/month Max 5x plan and you already paid before you opened your laptop, whether you touch it once or every day. Neither model is the cheap one in general; which one wins depends on how many sessions you actually run, how big they are, and how much of each one is doing real work versus carrying dead weight. That's a number you can compute, not guess at.

How API billing and subscription billing actually charge you

Claude API billing (the Claude Console, pay-as-you-go) charges per token across four buckets - fresh input, cache write, cache read, and output - each at its own rate, added up on every request (Anthropic's published pricing, fetched 2026-08-04). There's no monthly fee sitting underneath it and no hard stop: run nothing and the bill is $0.00, run a lot and the bill keeps scaling with what you actually sent and received. The full four-bucket formula behind that number is worth reading if you want the mechanics; what matters here is just that it's metered, linearly, with no ceiling.

A Claude subscription - Pro, Max 5x, or Max 20x - works the opposite way. You pay a flat fee (Pro $20/month, Max 5x $100/month, Max 20x $200/month, confirmed against claude.com/pricing) and get a rate-limit ceiling instead of a token meter: a rolling five-hour session window plus a weekly cap, with Opus tracked on its own separate weekly allowance (more on how that ceiling actually works). Stay inside it and extra usage costs nothing more. Go over it and you wait for the window to reset or upgrade tiers - there's no "just pay a bit extra for this session" option the way there is on API billing.

| | API billing (Console) | Subscription (Pro / Max) | | --- | --- | --- | | Price | Per token, four billing buckets, no fixed fee | Flat: Pro $20/mo, Max 5x $100/mo, Max 20x $200/mo | | Hard cap | None - genuinely pay-as-you-go | Yes - 5-hour rolling window plus a weekly cap | | Cost if you don't use it | $0.00 | Full price regardless | | Cost once you're inside the ceiling | Keeps scaling with tokens sent | $0 marginal - already paid for | | Where the number comes from | Anthropic's published per-model, per-bucket rates | A flat price set by plan tier, unrelated to token count |

Those are genuinely different pricing shapes, not two prices for the same thing - which is exactly why "which is cheaper" only has an answer once you attach a volume to it.

What one real session actually costs, priced at raw API rates

That's a 600,000-token session - this project's own modeled medium-session anchor, split across the four buckets using this project's own measured composition from 1,037 real Claude Code sessions (cache reads alone are 93.9% of billed tokens, the same mix the cost-calculator guide works through in full), and priced at Sonnet 5's current published rates. Sonnet 5 carries introductory pricing ($2/$10 per million input/output tokens) through 2026-08-31, after which it moves to $3/$15 - re-run this math with the new rates once that date passes rather than trusting this number afterward.

Your own sessions won't land on $0.234 exactly - a longer session, a different model, or a leaner setup all move it. What matters is that it's a real per-session dollar figure, computed the same way an actual API invoice would compute it, and it's the number the rest of this math divides plan prices by.

The breakeven: how many sessions before a subscription wins

Divide a plan's monthly price by what one session actually costs at API rates, and you get the exact session volume where that plan stops being the expensive option:

Below each threshold, paying per session on API billing costs less than the flat fee, because you're not yet using enough to fill what you'd have already paid for. Above it, the flat fee wins, because you'd be paying more per-token on API billing than the subscription's fixed price for the same volume. Nobody selling either plan publishes this crossover point, because Anthropic doesn't convert Pro or Max's rate-limit ceiling into a token count in the first place (the cost-calculator guide covers why that conversion doesn't exist) - it only shows up once you price a real session and do the division yourself.

A day-rate reading of the same numbers: under roughly 3 sessions a day, API billing beats every tier's price. Between about 3 and 14 sessions a day, Pro's flat fee beats API billing - but API billing still costs less than Max 5x would for that same volume, so upgrading past Pro isn't justified yet on price alone. Max 5x doesn't earn its cost over API billing until you're consistently past 14 sessions a day, and Max 20x needs roughly double that again.

Why the "36x cheaper" number floating around is only true sometimes

Search this topic and you'll run into claims that a subscription is dramatically cheaper than API billing - one widely shared post puts a number as high as 36x. The mechanism behind claims like that is real: Claude Code re-sends a session's whole history every turn, and almost all of that gets billed as a cache read at 10% of the input rate, not at the sticker input price - so pricing a heavy, cache-heavy workload against a flat plan fee can produce a dramatic ratio for someone running enough volume to clear the plan's breakeven by a wide margin. What that framing leaves out is the volume assumption doing the work: the same math run against a lighter user - someone under Pro's roughly-85-session/month breakeven - flips the other way, because they're paying a full flat fee for capacity a metered bill would never have charged them for in the first place. A single multiplier presented without the session count it assumes isn't wrong so much as incomplete; the breakeven above is what that missing number actually looks like.

What a wasteful setup does to this decision

A dead MCP server, an oversized CLAUDE.md, or unoffloaded exploration doesn't just cost tokens in the abstract - it moves both sides of this comparison at once. On API billing, waste is billed directly: every wasted token in that $0.234 session is real money, charged at the same per-bucket rates as the tokens that did useful work. On a subscription, waste doesn't show up as an extra line item, but it eats the same fixed rate-limit ceiling faster, which is exactly the mechanism behind Max upgrade decisions that turn out to be a waste problem wearing a budget problem's clothes - on one measured Claude Code history, cutting dead MCP servers, a bloated CLAUDE.md, and un-offloaded exploration bought back 38.7-46.8% more session headroom before hitting the same ceiling, for $0.

That means the breakeven chart above is only honest for your setup once your setup is clean. A session inflated by waste costs more on API billing than it needs to, which pushes your real breakeven session count down (you'd cross into "subscription wins" territory sooner than the math suggests) - and on a subscription, the same waste burns rate-limit budget you could have spent on real work instead. Either way, the fix is the same and it's free: trim the waste first, then run the comparison on what's left.

A decision path that follows from the numbers above

Put the two questions in order instead of guessing at both at once. First: how many sessions do you actually run in a month, and how big are they - a rough count from /usage or your own memory of the last few weeks is enough to place yourself against the breakeven chart above, or plug a sessions-per-day estimate into the cost calculator to see the same comparison run against your own pattern instead of this guide's modeled one. Second, before trusting that placement: is a meaningful chunk of each session's cost waste rather than work - dead MCP servers, a CLAUDE.md that reloads in full every session, or exploration that never got offloaded to a subagent - because that inflates the API-side of the math and shortens your real subscription-side headroom at the same time.

If your real volume sits comfortably under a plan's breakeven and your setup is already lean, API billing is the honest cheaper choice - you're not paying for capacity you won't use. If you're consistently running enough sessions to clear a tier's breakeven on genuine work, the flat fee is the better deal and no amount of trimming changes that; that's real, legitimate volume, not waste. The case worth pausing on is the middle: a session count that looks like it clears a plan's breakeven, but hasn't been checked for how much of that volume is padding rather than product.

When this math doesn't apply to you

This breakeven prices a single dimension - dollars per month - and that's not the only thing separating the two billing models. A subscription's rate-limit ceiling is a hard cap regardless of the dollar math: if your real workload needs more session throughput than a tier's 5-hour and weekly windows allow, no breakeven calculation makes that tier sufficient, and API billing's lack of a ceiling is the actual reason to pick it, not its price. The reverse applies too - a team running many parallel subagents or several people sharing one workflow will burn through API costs or a rate-limit ceiling in ways a single-session model like the one above doesn't capture at all; treat this as a starting estimate for a single regular user, not a team sizing exercise. And Sonnet 5's rates carry introductory pricing that changes on 2026-08-31 - the dollar figures above are only current until then.

FAQ

• Is Claude API billing actually cheaper than a subscription? Depends entirely on volume. Using this project's measured session cost (~$0.234/session at Sonnet 5 rates), API billing is cheaper below roughly 85 sessions/month against Pro, 427/month against Max 5x, and 854/month against Max 20x. Above those, the flat fee wins.
• Where does the "36x cheaper" claim come from? It assumes heavy, consistent usage well past a plan's breakeven point, where a subscription's flat fee spreads across enough sessions to undercut per-token API pricing by a wide margin. The same math run at low volume flips the other way, because you're paying full price for capacity you're not using.
• Does a subscription have a hard usage cap the way API billing doesn't? Yes. Pro and Max are gated by a rolling 5-hour session window plus a weekly cap, with Opus tracked separately. API billing has no such ceiling - it's pay-as-you-go with no hard stop, which is also why it can cost more if you run genuinely heavy volume.
• Should I fix setup waste before or after picking a billing model? Before. Waste inflates what a session actually costs on API billing and eats subscription rate-limit headroom faster on a flat plan - both sides of the comparison move once you trim it, so the honest breakeven only holds for a setup that's already lean.
• Will this breakeven match my own numbers exactly? No - it's built on this project's modeled 600K-token session and measured 1,037-session composition mix, not your transcripts. A bigger or smaller typical session shifts every threshold proportionally; divide a plan's price by your own average session cost to get your real number.

None of the numbers above replace looking at your own history: the free scan reads your real Claude Code transcripts and tells you what your sessions actually cost and how much of that is waste, before you commit to either billing model based on a modeled example.

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.