Claude Code pricing: what it costs and what it really costs

What Claude Code costs

Three numbers — $20, $100 and $200 a month — and none of them is the one that matters most.

C

Claude Code pricing by plan, July 2026

Verified against Anthropic’s plan comparison on 29 July 2026. Prices exclude tax.

The number that matters more is buried in Anthropic’s own developer documentation, and it reframes everything above.

Disclosure before we go further: this site earns referral credits when someone signs up for Claude. The invoice figures below are from my own account.

The number Anthropic publishes and nobody quotes

Anthropic’s cost management guide states that across enterprise deployments, the average cost is around $13 per developer per active day and $150 to $250 per developer per month, with costs staying below $30 per active day for 90% of users.

Read that against the plan ladder. Max 5x is $100, Max 20x is $200, and the published per-developer range straddles the price of the top consumer plan. I cover what $110 a month actually buys separately; this guide is about the number itself.

Be careful about what that does and does not prove. The $150–250 figure is what enterprise deployments are charged for unmetered consumption at API list rates. A subscription is not unmetered — it is capped by the session and weekly windows, so a Max 5x subscriber cannot spend their way to $250 of tokens even if they try. The two numbers are not directly comparable, and anyone telling you the subscription is “sold at a loss” is guessing at margins Anthropic has never published.

What the comparison does tell you is the thing worth knowing before you buy: if your working pattern resembles that average, a capped $100 or $200 subscription is the cheaper instrument than paying per token, and the limits are the mechanism that makes it cheaper. The caps are not a flaw in the deal. They are the deal, which is why the limits rather than the price are what people actually complain about.

Anthropic also flags the caveat that most write-ups drop: per-developer costs “vary widely based on model selection, codebase size, and usage patterns such as running multiple instances or automation.” Someone else’s average will not predict yours.

How does Claude Code pricing actually work?

You are mostly not buying features. The plan comparison is explicit that Max buys “5x or 20x more usage than Pro” along with higher output limits, earlier feature access and priority at busy times, and that is the bulk of the difference.

Two capability gaps are real, though, and the pricing page does not make them obvious. Per Anthropic’s model configuration docs, Pro, Team Standard and Enterprise subscription seats default to Sonnet 5, while Max, Team Premium and Enterprise pay-as-you-go default to Opus 5. And Opus with the 1M-token context window is included on Max, Team and Enterprise but requires usage credits on Pro. The plan table prints 200k on every consumer row, which is stale — current top models reach well beyond it.

So the ladder is mostly a usage ladder, with a model default and an extended-context entitlement riding along at the Max tier. Deciding between $20, $100 and $200 is mainly deciding how many hours you want before something stops.

Two limits, not one

Claude Code runs a rolling session window of roughly five hours alongside a separate weekly cap that resets on a fixed day. They move independently, and misreading them is the most common billing complaint about the product.

My own dashboard, captured mid-week while writing about this: the session meter read 7% used with nearly five hours left, and the weekly meter read 56% used and would not reset until Tuesday night. The first number looks like abundance. Only the second one predicts whether you will still be working on Friday.

There is a third limit that catches people out, and it behaves differently from the other two. The session and weekly windows are shared across every model, so switching models does not restore access once you have hit one. But Opus also carries its own model-specific ceiling, and when you hit that one — “You’ve hit your Opus limit” — switching to Sonnet with /model does keep you working. Knowing which message you are looking at tells you whether to switch models or stop for the day.

What the dollar figure in /usage is not

Run /usage on a subscription and the Session block reports something like Total cost: $0.55. That number is not your bill and never will be.

Anthropic’s documentation is explicit: the session block “shows API token usage and is intended for API users,” and Claude Code “computes the dollar figure locally from token counts priced at standard list rates,” so it ignores promotional pricing and contracted discounts. On Pro or Max, your usage is already covered by the subscription; the figure is an estimate of what those tokens would have cost at API list rates.

Read it as a usage gauge rather than a charge. It is genuinely useful for that — it tells you which sessions are expensive — but people who watch it accumulate and brace for an invoice are reading the wrong instrument. The plan usage bars on the same screen are the ones that predict anything.

What happens when you hit a limit

Two options, and the default is the good one. By default Claude Code stops and tells you when the window resets. That is the behaviour that makes the bill predictable, and it is why a Claude subscription behaves differently from a metered tool like Cursor.

The other option is usage credits, which let you keep working past the limit and are billed on top. They are off unless you turn them on. Mine sit at $0.00 with auto-reload off, which I would recommend to anyone who wants a bill they can forecast, because auto-reload is how a $100 plan becomes a variable one.

What do I actually pay for Claude Code?

Sticker prices are easy to look up. Here is what eight months of invoices look like.

I started on Pro in December 2025 at $20. By January I had moved to Max 5x at $100 and have stayed there every month since. From April onward every invoice reads $110, because tax collection started and my rate is 10%.

Nothing about my plan changed in April. The list price did not move. My cost rose 10% anyway, which is the first thing to know about the gap between what a pricing page says and what your card is charged.

That $110 covers everything: no credits purchased, no overage, no surprises. Set against Anthropic’s own $150–250 enterprise average, $110 sits well under — though, again, that is not a like-for-like comparison, because mine is a capped subscription rather than unmetered consumption. My weekly meter sitting near half-used mid-week suggests I am a fairly ordinary user.

Which plan should you buy: Pro, Max 5x or Max 20x?

The honest answer is that you cannot know in advance, and the plans are designed so you find out cheaply.

Start at Pro. Upgrading takes a minute, and within two weeks the weekly meter will have told you whether you are hitting a ceiling or imagining one. That is a better signal than any guide, including this one, because the variable that decides it is how much you delegate rather than how senior you are.

I reached Max 5x the slow way, by hitting Pro’s ceiling repeatedly in the middle of work. Pro never failed me on capability. It failed me on runway.

Annual billing

Pro is the only consumer tier with an annual option: $200 billed up front, which Anthropic shows as $17 a month against $20 monthly. The saving is about 17% measured on the annual totals ($200 against $240). Max is monthly only.

The catch is committing a year to a tool in a category that reprices every few months. I pay monthly for exactly that reason and treat the difference as insurance rather than waste.

What does Claude Code cost for teams and enterprise?

This is the part most third-party pricing write-ups get wrong, so it is worth being precise.

Anthropic’s help centre states that Claude Code is included with every Team plan seat, and that Premium seats “offer more usage for team members with heavier workloads.” Third-party pricing summaries frequently get this wrong, claiming that standard Team seats exclude Claude Code and that a Premium seat is required for access. That is not what the documentation says. The seat tier changes your allowance, not whether you have the tool.

Mechanically, Team and Enterprise work like individual plans. Each member’s usage draws from a per-seat allowance on the same rolling five-hour and weekly windows, and that allowance is shared with Claude chat and Cowork rather than being Claude Code’s own budget. That last detail matters for budgeting: a developer who also lives in Claude chat is drawing from one pool, not two.

Admin controls sit in the claude.ai console rather than the developer-facing Claude Console — a distinction that costs admins an afternoon the first time. You get a spend report in org analytics with per-user and per-model estimates and CSV export, updated daily. Alongside it sits an adoption dashboard covering daily active users and sessions. And once usage credits are turned on, you can set spend limits at organisation, group or individual level. Usage inside the seat allowance is not metered in dollars at all, so the spend report only shows up once credits are on.

Two practical notes for anyone sizing a rollout. Anthropic’s guidance on budgeting is blunt: budget more for a coding seat than a chat seat, because each Claude Code turn carries file contents, tool calls and multi-step reasoning, and one debugging session can consume more than a day of chat.

The second is counter-intuitive. If you are on the Console rather than seats, the recommended per-user rate limits scale down as the team grows:

The reason is concurrency: the bigger the org, the smaller the share using Claude Code at any one moment, and the limits apply at organisation level so individuals can temporarily exceed their calculated share. A 200-person org requests roughly 4 million TPM in total, not 200 times the small-team figure. The exception Anthropic flags is a live training session, where everyone hits it at once.

The honest advice for a team of any size is the same as Anthropic’s: pilot with a small group, measure, then roll out. The per-developer spread on this tool is wide enough that someone else’s average will not predict yours.

Subscription versus API: the actual rates

You can run Claude Code on an API key instead of a subscription, and for most people that is the expensive path. But it is the only way to see what your usage is actually worth, so the rate card is worth having.

Per million tokens, from Anthropic’s pricing documentation:

Three things in that table matter more than the numbers themselves.

Cache reads cost a tenth of input. This is the mechanism the whole product runs on. Claude Code re-sends your conversation constantly, and a cache hit is billed at 0.1× the input rate. A five-minute cache write costs 1.25× input and a one-hour write costs 2×, so the hour-long cache only pays for itself after two reads. That is precisely why Claude Code switches to the cheaper five-minute window the moment you start paying per token — and why the switch costs you anyway, for a reason covered further down.

Sonnet 5 is on introductory pricing that ends. $2 in and $10 out holds through 31 August 2026, then standard pricing of $3 and $15 takes effect. That is a documented 50% increase with a date on it, and it is the clearest evidence available that this category’s prices move.

Opus 5 is cheaper per token than Opus 4.1 was. $5 and $25 against the deprecated model’s $15 and $75. Per-token rates in this category have gone both directions.

There is one more thing that does not appear on any pricing page and changes real costs. Anthropic notes that Claude 4.7 and later models use a newer tokenizer that “produces approximately 30% more tokens for the same text.” Same words, more tokens, so a per-token rate that looks flat is not flat in practice. On a subscription this shows up as your allowance going less far than it used to.

A worked example

Anthropic’s own documentation shows a sample session reading like this:

claude-sonnet-4-6:  1.2k input, 5.3k output, 940.0k cache read, 50.0k cache write ($0.55)

Look at the shape rather than the total. Fresh input is 1,200 tokens. Cache reads are 940,000 — nearly 800 times as much. That single line is the whole economics of the product: almost everything Claude Code processes is your conversation being re-read, which is why cache behaviour drives your bill far more than how much you type, and why /clear between unrelated tasks is worth more than any other habit on the list below.

It also shows why a six-minute burst of API time can sit inside a six-hour session. The wall clock is not what you are paying for.

When the API is the right call

Three cases. Genuinely occasional use, where a monthly fee sits idle. Organisations that need per-project cost attribution, which the Console gives you through workspaces with their own spend limits. And pipelines where a per-seat subscription does not map to how the work runs.

For everyone else the arithmetic is the one at the top of this guide: if your usage resembles the published $150–250 range, a capped $100 or $200 subscription is the cheaper instrument, and the caps are what make it so. That is the same reasoning that eventually moved me off Cursor’s metered model.

One trap to know about. If you have ANTHROPIC_API_KEY set in your environment, Claude Code may authenticate with it rather than your subscription, and you will be billed per token while holding a plan you are not using. Check which one you are on before assuming your subscription is covering you.

What costs are not on the Claude Code pricing page?

None of these are fees. All of them change what you get for your money.

The cache lifetime drops from an hour to five minutes when you go past your limit

This is the one almost nobody covers. Claude Code re-sends your conversation with every request and re-reads it at a discounted cached rate. On a subscription that cache lasts an hour. The moment you start drawing on usage credits it drops to five minutes — a twelvefold cut, not a trim.

The mechanism is worth getting right, because it is the opposite of what it looks like. Claude Code does not drop to five minutes to punish you — it drops because a one-hour cache write costs 2× input against the five-minute window’s 1.25×, so the shorter window is cheaper to write once you are paying per token. Anthropic’s docs say so plainly: “Cache writes cost more at the one-hour TTL than at the five-minute TTL, so Claude Code automatically drops to the shorter one.”

The cost does not disappear, it moves. Any break longer than five minutes now misses the cache entirely and reprocesses your whole conversation as full-price input, where the hour-long window would have absorbed it. Step away for a coffee on a subscription and you come back to a cache hit; do the same on credits and you pay to rebuild your entire context. So the same working rhythm consumes more once you are past your plan limit, on top of the credits themselves costing money.

One related detail if you lean on subagents: they use the five-minute window even on a subscription, because the automatic one-hour TTL applies only to the main conversation.

Long sessions cost usage even when you are idle

Because the full conversation is re-sent each turn, a one-line question in a session that has been open all day still draws usage for the entire history. /clear between unrelated tasks costs nothing and is the single highest-value habit. /compact is not free, because summarising a large context is itself a large request.

Agent teams multiply it

Agent teams spawn multiple Claude Code instances, each with its own context window. Anthropic’s documentation puts this at roughly seven times the tokens of a standard session when teammates run in plan mode. They are disabled by default, which is the right default.

Extended thinking is billed as output

This is the lever almost nobody adjusts. Extended thinking is on by default because it genuinely improves hard reasoning, and thinking tokens are billed as output tokens — the expensive column, five times the input rate on every model. Anthropic’s docs put the default budget at “tens of thousands of tokens per request depending on the model.”

For work that does not need deep reasoning, that is a lot of the priciest token type spent on nothing. /effort lowers the level, /config can disable thinking entirely, and on models with a fixed thinking budget the cap is an environment variable:

In settings.json:

{
  "env": {
    "MAX_THINKING_TOKENS": "8000"
  }
}

Adaptive-reasoning models ignore a numeric budget, so use effort levels there instead. One caveat worth knowing before you reach for /effort mid-task: effort level is part of the cache key, so changing it recomputes your entire conversation with no cache hits. Set it at the top of a session, not in the middle of one.

Model choice is the biggest lever you control

Opus burns through limits faster than Sonnet, and Sonnet handles most coding work well. /model switches mid-session. This is the same lever that shows up on metered tools as a direct cost, and on a subscription as runway. For simple subagent work you can go further and specify model: haiku in the subagent config.

Scheduled tasks fire whether you are there or not

A scheduled task runs on its interval even while the session sits idle, and it sends your full context each time. If you have set one up and forgotten it, it is quietly drawing usage on a cadence you chose weeks ago.

Background usage

Small but real: conversation summarisation for claude --resume and some status commands consume tokens even when idle, typically under four cents a session. Worth knowing about, not worth managing.

How do you keep the Claude Code bill down?

The controls exist and most people never open them. Here is the whole toolkit in one place:

A few of those deserve more than a table row.

Set a spend limit on day one. On Pro and Max you can cap usage-credit spend before you form any habits. Treat hitting it as information rather than an obstacle.

Leave auto-reload off. It buys more capacity when you run low, which quietly converts a fixed subscription into a variable bill.

Check /usage, not your instinct. It shows plan usage bars and attributes recent usage to skills, subagents, plugins and individual MCP servers, each as a percentage. Press d or w to switch between the last 24 hours and the last 7 days. It also flags behaviours accounting for 10% or more of recent usage, like long context or cache misses.

Match the model to the task. Sonnet for most work, Opus for genuinely hard reasoning.

Keep CLAUDE.md under about 200 lines. It loads into context at session start, so anything in it is present on every request whether relevant or not. Move specialised instructions into skills, which load only when invoked.

Delegate the verbose work. Running a test suite, fetching documentation or grinding through log files eats context fast. Hand those to subagents and the noisy output stays in the subagent’s window while only a summary comes back to your conversation. A hook can do the same job earlier: instead of Claude reading a 10,000-line log to find the failures, a hook greps for ERROR first and returns the matching lines, which Anthropic’s own example describes as cutting tens of thousands of tokens down to hundreds.

Audit what MCP servers are costing you. Tool definitions are deferred by default now, so only names enter context until a tool is used, but /context shows what is actually consuming space and /mcp lets you disable servers you are not using. CLI tools like gh and aws stay more context-efficient than an MCP server because they add no per-tool listing at all.

Use plan mode before big changes. Shift+Tab into plan mode costs some tokens up front and saves far more by not building the wrong thing. Escape stops a run that is heading somewhere useless, and /rewind puts the conversation and the code back.

Is it worth the money?

That question has its own answer, and I have written it up separately in my Claude Code review with the full hands-on case. The short version for pricing purposes:

If you work in an existing codebase and can review what an agent produces, a capped subscription is a cheaper way to buy this than paying per token, for the reasons covered above. If you are choosing between this and a metered tool like Cursor, the comparison is not really about price at the entry tier, where both are $20 — it is about what happens above it, which I cover in Claude Code vs Cursor.

The thing to watch is durability. Prices in this category move, and this one already moved my bill 10% mid-subscription without my changing a plan. On the API side Anthropic has published the next increase in advance: Sonnet 5 goes from $2/$10 to $3/$15 per million tokens on 1 September 2026. None of that is a reason not to buy. It is a reason to re-check the number rather than assume the one you signed up for is still the one you are paying.

What are the cheaper alternatives to Claude Code?

Three places, and only one of them is genuinely cheaper.

Per user per month, excluding tax. Copilot figures from its plans page; Cursor’s from my own account.

Cursor — the closest substitute, and the one I also paid for. Its entry tier matches Claude Code’s at $20, so nothing is saved there. What differs is the shape above it: Cursor meters and keeps billing where Claude Code stops and waits. Over eleven months that cost me $510.70, a third of it metered usage on top of the subscription. Cheaper in a light month, more expensive in a heavy one, and you find out afterwards. My full comparison has both invoice histories side by side.

GitHub Copilot — the genuinely cheaper option. Pro is $10 per user per month with unlimited code completion and $15 of monthly credits, and there is a free tier at 2,000 completions per month, which is more than Claude Code offers at $0. Pro+ is $39 and Max is $100. If your use is mostly completion rather than agentic multi-file work, this is half the price for the part you actually use.

OpenAI Codex — bundled into a ChatGPT subscription rather than priced on its own, which makes it close to free if you already pay for ChatGPT. The plan comparison grades access rather than selling it separately: Free and Go get “Limited” Codex, Plus gets “Expanded Codex usage”, Pro gets “Maximum Codex tasks”. I have not tested it yet, so treat that as the structure rather than a recommendation.

Skip all three if what you actually want is a bill that cannot surprise you. That is the one thing Claude Code’s default behaviour gives you and metered tools do not.

The short answer

Claude Code costs $20, $100 or $200 a month, plus your local tax, with no free tier and no separate Claude Code price. Pro is a real entry point rather than a demo. Max 5x is where most working developers land. Max 20x is for people running agents all day.

Set a spend limit in your first week, leave auto-reload off, check the weekly meter rather than the session one, and start a tier lower than you think you need. Do that and the price you see is the price you pay, which is rarer in this category than it should be.