Claude Code costs: what you actually pay and how to cut it

“Cost” on a Claude Code subscription isn’t just dollars — it’s how quickly you burn through your weekly cap. Every wasted token is a token you can’t spend on real work later in the week. The good news: most waste falls into a few predictable buckets, and once you can see them, they’re fixable. Here’s what you actually pay, where the tokens usually go, and what to do about each.

Subscription or API: two different bills

Claude Code can be paid for two ways, and they fail differently.

On a Claude subscription, Claude Code is included in the plan. You are not billed per token, so the meaningful cost isn’t dollars at all — it’s your usage cap. Run out and the work stops until the window resets, no matter how much value the next prompt would have delivered. The question that matters is how much work you get per cap.

On API billing, you pay per token and the bill scales directly with how much context each turn carries. There’s no wall to hit, but there’s no ceiling on the invoice either, and the same waste that burns a subscription cap shows up as real money.

Most people doing daily agent work land on a subscription, which is why the rest of this page is about mileage rather than rates: on a fixed plan, cutting waste is the only way to buy yourself more work.

So is it expensive?

The honest answer is that the sticker price is predictable and the mileage isn’t. Two developers on identical plans routinely get very different amounts of work done before capping out, and the gap is rarely about how hard they’re working. It’s about how much of their context is noise — logs, re-read files, extra agent overhead — riding along on every turn.

That’s the part you can change, and it’s what the three sections below break down.

1. Noisy tool output

The single most compressible category is tool output: build logs, test runs, JSON blobs, HTML, and stack traces that get dumped into the context whole. A failing test suite can spray thousands of near-identical lines into your prompt, and the agent re-reads all of it on the next turn.

You don’t need every line — you need the signal (errors, failures, the shape of the result) and can drop most of the repetition. That’s the kind of waste reversible compression is built to trim.

2. Re-reading the same files

The sneakiest drain is repeated file reads. Agents re-open the same files across turns, and near-identical context piles up fast — filling the context window until the session has to compact, which costs tokens of its own.

In one example from a real week of usage, file re-reads accounted for roughly 40% of content token burn — and a single file was read 22 times in one week.

That’s not an edge case; it’s the default behavior of a stateless agent that re-fetches context instead of remembering it. Cutting that repeated payload — without throwing the originals away — is one of the largest savings pools in coding agents.

3. Sub-agents multiplying the bill

Sub-agents are powerful, but each one carries its own context, and that adds up quietly.

In that same example week, sub-agents accounted for about 37% of total burn.

Spawning a sub-agent for a task that a focused prompt could handle can double or triple the tokens spent on it. The fix isn’t to stop using them — it’s to see when they’re firing and what they’re loading, so you can rein in the expensive ones.

What compression actually does

Reversible compression sits between Claude Code and the model as a local proxy on your machine. It trims the noisiest parts of each prompt before they reach the API, keeps every original retrievable, and leaves source code alone on purpose. Details of how that trimming works stay in the product — how it works covers the trust story without a build brief.

Because we’re pre-launch, we’d rather under-promise on savings numbers: run the audit and judge the potential on your own data.

See your own numbers first

Before changing anything, measure. The free hypermile-audit CLI reads your local Claude Code transcripts — on Windows, WSL, macOS, or Linux — and breaks your week into exactly these categories, with no upload. It’s open source, and it’s the fastest way to find out whether your waste is logs, re-reads, or sub-agents.

Run it below, then download Hypermile that trims this automatically — or see how the compression works first. If you’re billed through the API and want to price a specific workload, the Claude token calculator does that math. New to the limits themselves? Start with how Claude Code usage limits work on Windows, compare the tooling in our usage trackers roundup, or head back to the overview.