Claude Code API vs Max Plan Cost: The Break-Even Math

A 12-step Claude Sonnet 5 agent run costs $0.38 on the API uncached, or $0.11 with prompt caching. That single number, not the subscription price, is the anchor for this whole comparison, because whether Max or Pro beats pay-as-you-go API billing depends entirely on how many runs like that one you execute each month against whatever the plan costs.

We have verified, current API unit costs for Claude Sonnet 5, Claude Opus 5 and Claude Haiku 5.5, and a reference 12-step agent trace cost for each. We do not have a verified Claude Code Max monthly subscription price in our grounding data, so this guide will not state one. What we can give you is the decision rule, applied correctly, so you can finish the math yourself in thirty seconds once you have the official number in front of you.

The rule: break-even runs = monthly subscription price divided by the per-run API cost of the model you would otherwise be calling. If your workload is mostly Sonnet 5 at $0.38 per uncached run, divide the confirmed plan price by $0.38 to get your break-even run count; divide it by $0.11 instead if you cache consistently. The gap between those two divisors is the entire argument for caching before you even think about which plan to buy.

So the honest short answer is: fetch the current Pro and Max prices from the official Claude pricing page, plug them into the formula below with your own run volume, and use the calculator to confirm. Nobody should buy a subscription based on a guess, and nobody should keep paying API rates without doing this division at least once a quarter.

These are the verified figures this entire guide is built on. Claude Sonnet 5 costs $2 per 1M input tokens and $10 per 1M output tokens, with cached input at $0.2 per 1M. Claude Opus 5 costs $5 per 1M input and $25 per 1M output, cached input at $0.5 per 1M. Claude Haiku 5.5, released 7 October 2026, costs $0.10 per 1M input and $0.50 per 1M output for prompts up to 100,000 tokens, with cache hits at $0.01 per 1M. Prompts over 100,000 tokens bill the whole request at $0.50 / $2.50. It replaces Claude Haiku 4.5, now a legacy model at $1 / $5, which ran $0.19 uncached and $0.06 cached on this trace.

On the reference 12-step agent trace (4,000-token prefix, 500-token task, each step adding a 300-token tool call and a 1,500-token result, totaling 172,800 input tokens and 3,600 output tokens), the costs are:

• Claude Sonnet 5: $0.38 per run uncached, $0.11 per run cached
• Claude Opus 5: $0.95 per run uncached, $0.29 per run cached
• Claude Haiku 5.5: $0.019 per run uncached (172,800 × $0.10 + 3,600 × $0.50 per 1M), $0.0057 per run cached

These are the only Claude numbers you should plug into a break-even calculation. If you see a different per-run figure quoted elsewhere, check whether it's using a different step count or token mix before trusting it. The gap between cached and uncached is what matters most here: Sonnet 5's cached cost is less than a third of its uncached cost, which more than triples the number of runs a fixed-price subscription needs to beat even.

The formula is simple: break-even runs per month = monthly subscription price divided by cost per run. Once you have the official Max or Pro price from Anthropic, here is exactly how to apply it against each model.

For uncached Sonnet 5 work, divide the confirmed monthly price by $0.38 to get the number of runs per month where the subscription and the API cost the same. Below that run count, pay-as-you-go API billing is cheaper; above it, the subscription wins.

For cached Sonnet 5 work, divide the same confirmed price by $0.11 instead. Because caching cuts the per-run cost to less than a third of the uncached figure, the break-even run count is more than three times higher once caching is in place, meaning a subscription has to clear a much higher usage bar before it pays for itself against a caching API user.

For Opus 5 planner work, divide the confirmed price by $0.95 uncached or $0.29 cached. Because Opus 5 is the most expensive per-run model in this lineup, dividing by it produces the lowest break-even run count of the three, which matters if your workload leans on Opus 5 for planning rather than Sonnet 5 for execution.

Run these three divisions the moment you have Anthropic's actual Pro and Max prices in hand; the formula doesn't change, only the numerator does. The calculator can hold your run counts and per-run figures side by side if you don't want to do the division by hand.

Scenario one: a solo developer building chat-ops agents, running a few dozen Sonnet 5 agent runs a day. At $0.38 per uncached run, or $0.11 per cached run, multiply either figure by your actual monthly run count to get a hard floor the subscription has to beat. A developer who caches consistently is comparing the subscription against a much smaller number than one who doesn't.

Scenario two: an SMB running background agents at a few hundred runs a day, with a mixed workload of Sonnet 5 executor runs and Haiku 5.5 worker runs. Take your actual split between the two models, multiply each share by its per-run figure ($0.38 or $0.11 for Sonnet 5, $0.019 or $0.0057 for Haiku 5.5), and add the two together. At this volume, a hybrid approach, subscription for human-interactive sessions plus API with caching for the automated background agents, is worth modeling explicitly, since no individual seat-based plan is built for thousands of unattended machine calls.

Scenario three: a high-throughput orchestrator running thousands of runs a day, mostly Haiku 5.5 worker calls with an Opus 5 planner firing periodically. Apply the cached Haiku 5.5 figure of $0.0057 per run to your worker volume and the cached Opus 5 figure of $0.29 per run to your planner volume, then add the two. At this scale, no consumer or team subscription plan is designed to cover the volume, and the API with aggressive caching and Message Batches for anything that can be queued is the only workable path. Run your own numbers through the calculator rather than trusting a generic example.

These are the exact unit costs and reference-trace figures used throughout this guide. The DeepSeek row uses DeepSeek's peak rates; off-peak is half. The Haiku 5.5 row is for prompts up to 100,000 tokens (checked 2026-11-03); every step of this trace is under 25,000. DeepSeek pricing checked 2026-10-27 at api-docs.deepseek.com. If you want a side-by-side against OpenAI or Gemini for the same 12-step trace, the full table lives in the models and pricing pages linked below. Notice how much the cached column shrinks every row: that's prompt caching doing its job, and it's the single biggest lever on whether a subscription or the API wins your particular workload.

Prompt caching is not optional if you're trying to decide between a subscription and API billing, because it moves the API side of the comparison dramatically. Claude Sonnet 5 drops from $0.38 to $0.11 per 12-step run when the stable prefix is cached. Claude Opus 5 drops from $0.95 to $0.29, and Claude Haiku 5.5 drops from $0.019 to $0.0057. Any break-even calculation that uses the uncached number when your production setup actually caches is going to overstate how attractive the subscription looks.

Message Batches is a separate lever and it only applies to a different kind of workload. It suits fan-out work, scoring a backlog of tickets, running the same short agent over thousands of independent items, where each request doesn't depend on the previous one's result. It does not apply to a live, interactive agent loop where step two needs the output of step one, which is exactly the kind of workload Claude Code Max or Pro is built to serve interactively. So when you're comparing subscription vs API, caching is the relevant discount for both the subscription use case and the API use case, while Message Batches is only relevant to the pure-API side of a batch-style workload.

Rate limits and latency matter too: a subscription plan is sized around one person's interactive pace, not a service firing hundreds of concurrent requests. If your orchestrator needs to burst past what the plan allows, you need API access for the overflow regardless of how attractive the subscription price looks on paper.

Even once you know the Max price, the break-even formula doesn't capture everything. Claude Code, whether on a subscription or driven through the Agents SDK, is a specific product with specific plan mechanics, and it's worth checking a few things before committing budget. First, concurrency: if the plan throttles how many requests you can run in parallel, a workload that needs to fan out, say running agents against 50 items simultaneously, may still require falling back to API billing for the overflow even if you're paying for a subscription for the baseline load.

Second, model access: confirm which models are actually included under a given plan tier before assuming Opus 5 planner access is bundled the same way Sonnet 5 executor access might be. Plans sometimes gate the most expensive model behind the higher tier, which changes the math for anyone running an Opus 5 planner plus Sonnet 5 executor pattern.

Third, latency and reliability under load: API calls you make directly give you full control over retries, timeouts, and failover to a second model if one is overloaded. A subscription-wrapped interface may not expose the same level of control, which matters for a production agent that needs predictable tail latency more than it needs the cheapest possible unit cost.

None of these change the raw arithmetic in the break-even formula, but they change whether the cheaper number on paper is actually the cheaper number in practice once you account for engineering time spent working around plan limits.

A common multi-agent pattern uses Claude Opus 5 as the planner that decides what to do and Claude Sonnet 5 as the executor that does it, each running the 12-step reference trace. Per planning-and-execution cycle, the cost is one Opus 5 run ($0.95 uncached, $0.29 cached) plus however many Sonnet 5 executor runs that cycle triggers, each at $0.38 uncached or $0.11 cached. Add the Opus 5 figure to the Sonnet 5 figure multiplied by your executor count per cycle to get a per-cycle total, then multiply by cycles per month.

Put that monthly total against a subscription price once it's confirmed, remembering that a plan covering one person's interactive Claude Code usage is a different product from an API-billed multi-agent orchestration pipeline running on the Agents SDK. If your planner-to-executor ratio changes, so does the comparison: more planner calls relative to executor calls push the bill up faster, since Opus 5 costs roughly 2.5 times Sonnet 5 per run at the same step count.

Pick Claude Code Max or Pro when your usage is one person, interactive, and session-heavy: coding sessions where context stays warm and cached across a long back-and-forth. That's exactly the profile the break-even formula favors a subscription for, once the official price is confirmed, because cached Sonnet 5 runs at $0.11 each add up fast against any fixed monthly fee.

Pick pay-as-you-go API billing when your workload is unattended, parallel, or embedded inside a product: background agents, orchestrators, anything running thousands of runs a month across multiple concurrent sessions that a single-seat plan was never built to cover. The second and third buyer scenarios above both land here.

Pick a hybrid when you have both: a developer who codes interactively during the day and also runs a background agent fleet. Put the interactive work on a subscription and bill the background fleet through the API with caching and, where applicable, Message Batches.

Next steps: fetch the current Pro and Max prices from the official Claude pricing page, run your own monthly run count through the calculator, and test your actual concurrency needs against the plan's rate limits before committing a budget line to either option.

Start with the AI cost calculator to plug in your own run counts against the Sonnet 5, Opus 5, and Haiku 5.5 per-run figures above once you have a confirmed subscription price to compare against. For the mechanics of prompt caching that drive the cached-run numbers in every example here, read the prompt caching guide. If you're trying to cap spend on an agent regardless of which billing model you choose, the agent budget guardrails guide covers hard step caps and per-run USD ceilings. And for the general question of when a subscription beats metered API billing across any vendor, not just Anthropic, the subscription vs API comparison lays out the same break-even logic in a vendor-neutral way.