I've been using Claude Code daily since June 2025. Over the first eight months of that I ran something like 10 billion tokens through it, and when I dug through my local session logs to work out what the same usage would have cost on API pricing, the number came to over $15,000. I paid roughly $800. That maths is what the original version of this guide was built on and it hasn't changed.

What has changed is that I've spent the last six months barely using it, and that turns out to be the more useful half of the story. The heavy-usage case is easy and everyone writes about it. If you're burning through billions of tokens a month, Max pays for itself and there's nothing to think about. The harder question, and the one I've actually had to answer myself this year, is what to do when your usage drops and you're staring at a $100 subscription wondering whether you still need it.

Prices have moved too, and a fair amount of what's currently published about them is wrong. I've updated everything against Anthropic's own pricing page rather than working from memory.

Update: I built an open source tool so you can see exactly where your own spend is going. Read more and get it here: Claude Cost Tracker. For teams, I've built Headroom.

What I used between June 2025 and February 2026

This is the original dataset and I've left it exactly as it was. It covers dozens of projects, from an SMTP relay for email tracking through to synthetic genomic data work, analytics dashboards and various smaller utilities. I was on Max 20x ($200/month) through the heaviest months and dropped to 5x ($100/month) when I stopped coding in a day job.

For June through August I have full token-level data from the local sessions database. The later months are estimated from prompt counts and session logs, which is worth flagging because on a subscription plan the only way to see your real usage is to dig through the files in your ~/.claude/ directory. Anthropic doesn't surface it in a dashboard the way the API does. September had no usage at all so I've left it out.

The $5,623 month

July 2025 was the outlier. I ran 201 sessions across more than 45 projects, and the API equivalent came to $5,623. That single month is worth more than four and a half years of Max 5x.

I was building several things at once, an analytics dashboard for AI code metrics, a profiling tool UI, and iterating on the email infrastructure for Cont3xt. A lot of it was exploratory, having Claude Code tear through codebases to understand architecture decisions I hadn't made myself. That kind of open-ended work is where the tool earns its keep and it's also where it burns tokens at a rate that would be genuinely painful billed per token.

On the busiest single day I tracked, 22 January 2026, I hit 8,930 messages across 9 sessions with 2,169 tool calls.

Where the tokens actually go

Over 90% of all tokens are cache reads. Input and output, the ones you'd think about, are a tiny fraction of the total. Cache writes account for about 6%, and actual input and output combined is under 1%.

This is because Claude Code is constantly caching context about your codebase. Every file it reads, every function it holds in working memory, all of that runs through the cache system, and if you're switching between files on a large project the cache operations dominate everything else.

Cache reads bill at 10% of the input rate, so $0.50 per million on Opus. My 4.5 billion cache reads came to roughly $2,250 at that rate. Billed as fresh input at the full Opus rate of $5 per million they'd have been $22,500. The caching discount is doing an enormous amount of work, and it's the single biggest reason API pricing at this volume isn't as catastrophic as it first looks. It's still expensive.

The quiet six months

Since February I've used Claude Code a few hours a week. Not a deliberate decision, just a stretch where I've been doing less hands-on building. Mostly Opus, because when I do sit down it's usually for something I actually need the reasoning on rather than routine edits.

I've been switching between Pro at $20 and Max 5x at $100 depending on the month, which is exactly the decision this guide should have been answering all along and wasn't.

What I've found is that the breakeven is much less clean at this end than it is at the top. On heavy usage the answer is obvious because you're comparing $100 against a four-figure API equivalent. At a few hours a week you're comparing $100 against maybe $20 to $40 of API equivalent, and Max stops being an obvious saving and starts being a convenience purchase. You're paying for not thinking about it, for not watching a meter, and for Opus access without a session limit interrupting you halfway through something.

That's a real thing to buy and I don't think it's irrational. It's just worth being honest that it's what you're buying, rather than telling yourself it's saving you money when it isn't.

The thing that makes Pro genuinely awkward at Opus-heavy usage is that a few hours a week of Opus work will bump into session limits in a way the same hours on Sonnet won't. So the honest version of the light-usage answer isn't "get Pro", it's that your model choice decides it for you.

How many tokens do you actually get on Pro

This is the most common question I see about Pro pricing and it doesn't have the answer people are looking for. Anthropic doesn't publish a token allowance for Pro or for either Max tier. The limits are expressed in sessions and messages, they reset on a rolling basis, and how far a session gets you depends almost entirely on how much context you're carrying.

That last part is why two developers on the same plan report wildly different experiences. A session working in a tight, well-scoped repo with a small CLAUDE.md will go a long way. A session hauling a bloated context file and forty open files into every turn will hit the wall in a fraction of the time, because the cache reads scale with what you're carrying rather than what you're asking. I've written separately about the workflows that keep that number down, and the short version is that context discipline is a cost lever long before it's a quality lever.

If you hit your limit, you can enable usage credits which bill at standard API rates on top of the subscription. So the practical answer to "how many tokens do I get on Pro" is that you can't know in advance and you should measure your own. Which is the whole reason I built a tracker.

The pricing as it stands in August 2026

API, pay as you go. Per million tokens:

Cache reads bill at 10% of input. Cache writes are 1.25x input on the five minute TTL and 2x on the one hour. The Batch API takes 50% off both directions for anything that doesn't need to be real time.

One correction worth making loudly, because a lot of pricing sites currently have it wrong. Sonnet 5 launched at $2/$10 as introductory pricing that was scheduled to rise to $3/$15 on 1 September 2026. That increase has been cancelled and $2/$10 is now the standard price. If you're budgeting off a comparison site that still shows a September rise, it's out of date.

Claude Pro, $20/month ($17 billed annually). Opus 5 is available but you'll meet session limits sooner on it than on Sonnet.

Claude Max, $100 or $200/month. The 5x tier at $100 and the 20x at $200. Opus 5 is the default model on Max, and both tiers get priority during peak demand.

Which plan for which usage

The old version of this guide gave a single breakeven, which was fine when I was only writing about heavy usage. The honest version has more than one axis, because the model you use moves the line more than the hours you put in.

The mechanical rule still holds underneath all of it. If your monthly API equivalent is over $100, Max 5x saves money. Over $200 and the 20x tier does. What the table adds is that at the light end the saving isn't the only thing you're deciding, and at the heavy end the model split matters more than the total.

Model choice moves the number more than it used to

My original 10 billion tokens were about 95% Opus. At the time the alternative was Sonnet at $3/$15, so switching would have cut the bill by roughly 40%.

Sonnet 5 at $2/$10 changes that calculation considerably. Against Opus 5 at $5/$25 you're now looking at 60% off input and 60% off output, on a model that handles most routine work without a meaningful drop in output quality. The argument for reserving Opus for genuinely hard architectural problems and letting Sonnet take the routine edits and subagent work is much stronger than it was six months ago, and I've been testing that split across tools rather than assuming it.

On a subscription this doesn't touch your bill directly. It does decide how quickly you hit limits, which is the same thing in a different currency.

How to check your own usage

If you're on the API, Anthropic's dashboard shows costs directly and you can stop reading.

On a subscription you have to go looking. The session data lives in ~/.claude/ as JSONL files, and you can parse them for prompt counts, token usage and session durations. It's a tedious job, which is why I built cctrack, a Go binary that reads those logs and gives you a live cost dashboard for your own machine. It's open source, it runs locally, and for answering "am I on the right plan" it's all you need.

Where it stops is the moment the bill isn't yours.

When someone else is paying

The first time I got asked about this it wasn't about my own spend at all. It was a developer who'd run cctrack, worked out his own plan was wrong, and then realised he had no idea whether the other eleven people on his team were on the right ones either.

That's a harder problem than it sounds. Subscription seats don't produce an itemised bill, so a developer who stopped using the tool in March looks identical on the invoice to one hitting limits daily, and the person signing the renewal can't tell them apart. At $100 to $125 a seat, one forgotten licence is over a thousand pounds a year of nothing. You can't fix it by running cctrack twelve times either, because nobody's parsing eleven colleagues' local log files.

So the hosted version of that is what I'm building as Headroom. Claude Code already emits OpenTelemetry, so it reads that stream out of band and turns it into spend per developer, per repo and per model, then produces a per-seat recommendation for what each person should actually be on at renewal. Metrics only, never prompts or code, nothing in the request path, and it self-hosts if the telemetry shouldn't leave your network. It's in early access and design partners get the hosted plan free while I build the renewal report with them.

Run cctrack first. If the answer you get makes you wonder what the rest of your team is on, that's the point Headroom exists for.

Where I've landed

For the eight months I was building constantly, Max was the best value decision I made on tooling. The $5,623 I'd have spent in July alone covers four and a half years of Max 5x, and there was never a month where the maths was close.

For the last six months at a few hours a week, it's been much closer, and I've been honest with myself that when I'm on Max at this usage level I'm buying convenience rather than savings. That's a legitimate thing to buy. It's a different decision from the one this guide originally described and it deserved saying out loud.

If Claude Code is how you work every day and you lean on Opus, get Max and stop thinking about it. If you're dipping in a few hours a week, start on Pro, run a tracker for a fortnight, and let your own numbers decide. Most people guess this and most people guess wrong in the expensive direction.