Claude Code Pro vs Max vs API billing: which is cheaper for you

Short answer: if you run Claude Code most working days and regularly hit the point where it tells you to wait, a subscription tier is almost certainly cheaper than metered API billing, because the flat fee is priced well under what the same token volume would cost at list rates. If you use Claude Code in bursts, a few sessions a week, on small repos, pay-as-you-go API billing usually wins, because you pay for nothing on the days you do not open the terminal. The tier above the one you are on is only worth buying if you are being throttled, not if you merely feel like a heavier user than you are.

The reason people get this wrong is that nobody has the number. Anthropic bills a subscription as a flat monthly charge and enforces it with usage limits rather than a running total, so the dollar value of what you consumed never shows up anywhere. Metered API billing shows you a number, but it arrives at the end of the month, after the decisions that produced it. Both directions leave you reasoning about your own habits from memory, and memory is a bad instrument here. I have watched people describe themselves as heavy users while running maybe forty short sessions a month, and describe themselves as casual while leaving an agent grinding through a monorepo every afternoon.

The three billing shapes, and who each one fits

Claude Code can be paid for in three ways. A Pro subscription bundles Claude Code access with the chat product at the entry price point, with limits that suit light or intermittent coding use. Max tiers sell you a multiple of the Pro allowance at a correspondingly higher flat price, and are aimed at people whose day is structured around an agent. API billing charges per token, per model, with separate rates for input, output, cache writes and cache reads, and no ceiling other than the one you impose.

Anthropic enforces subscription tiers with both a short rolling window and a longer weekly window. That second window is the one that catches people. You can be comfortably inside your session limit every day and still run out on a Thursday because Monday and Tuesday were expensive. When that happens, the honest options are to wait, to upgrade, or to fall back to API billing for the overflow. Which of those is right depends entirely on how often it happens.

• You are on Pro and never hit a limit: stay. Upgrading buys you headroom you are not using.
• You are on Pro and hit the weekly limit once a month: stay, and keep an API key configured for the overflow. Paying metered rates for a few hours beats paying a higher flat fee for a whole month.
• You are on Pro and hit the weekly limit most weeks: move up. At that frequency the flat fee is the cheaper unit of consumption, and the time you lose waiting has a real cost.
• You are on a Max tier and have never seen a limit warning: you are very likely overpaying. Drop a tier and see whether anything actually breaks. It is reversible.
• You code with an agent fewer than about three days a week: API billing, with a spend cap. Subscriptions charge you for the idle days.
• You need Claude Code inside CI, or driven by a script, or on a machine nobody is sitting at: API billing. Subscription auth is meant for an interactive human.

What actually drives the bill, if you are metered

If you choose API billing, three things dominate, and none of them is the thing people worry about.

The first is model choice. The frontier model in the family costs a large multiple of the mid-tier model per token, in both directions. A meaningful share of agent traffic is not frontier-grade work: rename this symbol, summarise this file, write a commit message, decide which of these four files to open next. Running all of it on the most expensive model available is the single most common way to turn a modest month into an alarming one.

The second is prompt caching. Coding agents resend an enormous, nearly identical prefix on every turn: system prompt, tool definitions, project instructions, the files already in context. Cached reads of that prefix are billed at a small fraction of the normal input rate, while writing a cache entry costs a premium over normal input. The practical consequence is that anything which perturbs the front of your prompt destroys the cache and re-bills the whole prefix at write rates. This is why aggressive prompt compression schemes often make a bill worse rather than better. Stability at the front of the context is worth more than brevity.

The third is loop length. Cost per session scales with the number of tool round trips, and the number of round trips scales with how vague the instruction was. A precise task with named files usually costs a fraction of the same task described loosely, because the agent stops searching. This is the one lever that requires no tooling at all.

How to measure your own usage in an afternoon

You do not need to guess. Claude Code writes a local session log, and there are open source readers that parse it into a per-day, per-model token report and price it against published rates. ccusage is the best known of these, and claude-code-usage-monitor gives you a live view of where you sit inside the current limit window. Both are read-only and run against files already on your disk.

Run one of them across a normal fortnight, then do this arithmetic. Take the priced total for the period, double it for a month, and compare that number against your subscription fee. If the priced total is comfortably below what you pay, you are subsidising Anthropic and should either drop a tier or move to metered billing. If it is well above, the subscription is doing its job and you should stop worrying about it. If it is within about twenty percent either way, stay where you are, because the switching cost is not worth chasing a small delta.

One caveat on those tools: they read Claude Code's own logs, so they see Claude Code and nothing else. If you also run Codex or Cursor, their spend is invisible to a Claude-specific reader, and the tier question you are actually asking is usually about your total agent budget rather than one vendor's slice of it.

Where Probe0 fits

I built Probe0 because I got tired of answering this question with vibes. It is a proxy that runs entirely on your Mac. Every coding agent CLI on the machine routes through it after a one-time certificate install, so Claude Code, Codex and Cursor all land in the same ledger: model, token counts, real cost, latency, and which process made the call. There is no Probe0 server and nothing leaves your machine. After two weeks of normal work you have the number, across all your tools, and the plan-tier question answers itself. Probe0 will tell you outright when your measured usage sits below the tier you are paying for.

The modules that reduce the bill are separate from the measurement and each one is individually switchable, with its own savings figure. Model Tiering sends the cheap work to a cheap model. Local Routing hands a request to a model already running in Ollama or LM Studio and retries on the cloud when the answer comes back weak. Exact Cache and Semantic Cache serve repeats from local disk, and the semantic index refuses to match anything carrying tool calls, because a plausible-but-wrong hit in the middle of a tool loop corrupts the run. Request Coalescing collapses simultaneous identical calls into one upstream request. Spend Guard puts a hard cap on a run or a day, warns first, then pauses.

Honest limits, so you can rule it out quickly: macOS only, private beta, single developer on a single machine. It is not a team gateway and it does not pretend to be a hundred-provider catalog. If you need shared deployment, per-team budgets or SSO, a hosted gateway is the right shape of tool and Probe0 is not. Sign-in is Google or GitHub, and the account system is new.

The tier you should be on is a measurement, not a personality trait. Two weeks of ledger beats any amount of introspection about whether you are a heavy user.

The decision, compressed

Measure first, for two weeks, with any tool that reads your local logs. Compare the priced total against your flat fee. Move down a tier if you are under it, move up only if you are being throttled often enough that waiting is costing you working hours, and go metered if your usage is spiky or unattended. Then, separately from the billing question, take the cheap wins: keep the front of your context stable so caching survives, stop routing trivial turns to the most expensive model, and give the agent precise file names so it stops searching. Those three habits move the number more than most tier changes do.