Claude Code Pricing Deep Dive (2026)

Most people think Claude Code pricing is about tokens. You use the model. You pay for the tokens. The bill arrives.

That's not wrong. But it misses the big picture.

I tracked a 170-turn Opus session. Without caching, it would have cost $168. With caching: $21. Over 98% of the input tokens were cache reads, billed at $0.50 per million instead of $5.

I've been running Opus 4.6 daily for a few months now. I built Claude Code Camp with it. For this deep dive series, I ran 30 API calls to measure thinking costs. I tracked session tokens turn by turn. I pulled cost data from public case studies.

Claude Code needs a paid plan. Pro at minimum. There are four subscription tiers (Pro, Max 5x, Max 20x, Team) plus a direct API path. They differ in price, usage limits, and default model. Max and Team Premium run Opus 4.6 by default. Pro and Team Standard run Sonnet 4.6.

One caveat: Anthropic doesn't say what "5x Pro limits" means in exact message counts. We know the multiplier and the price. Not the ceiling.

The model default matters. Pro gives you Sonnet 4.6. Max gives you Opus 4.6. Both work well. Opus reasons deeper on hard tasks. You can change the default with --model or ANTHROPIC_MODEL, but your plan's usage limits still apply.

Yes. The free Claude.ai tier does not include Claude Code. You need at least Pro ($20/month) or a Console account with API credits.

Pro is the starting point. You get Claude Code with Sonnet 4.6, standard usage limits, and the full feature set: slash commands, MCP servers, CLAUDE.md, the agentic loop. The limit is on how much you use it. Not on what it can do.

Before we talk about costs, here's what you're paying for. Every message in Claude Code triggers five steps:

Steps 1-3 are input. Steps 4-5 are output.

Input is cheap because of caching. Output is expensive because of how GPUs work. That's the split that drives everything on this page.

This isn't random markup. It reflects how the hardware works.

Input tokens are read in parallel. The GPU handles thousands at once. That makes each one cheap.

Output tokens are written one at a time. Each token depends on the one before it. The GPU generates one, feeds it back, generates the next. It's like a highway used for single-file traffic.

Thinking tokens are output tokens too. When Claude reasons through a problem, every reasoning token costs the output rate. On Opus 4.6, that's $25 per million tokens. Same price whether you see them in your terminal or not.

Caching works on the input side because reading is already cheap. It makes a cheap operation 10x cheaper. Output can't be cached. There's no shortcut for writing one token at a time.

These are the per-token prices if you're on the API. They also show what drives subscription costs under the hood.

Opus 4.6 was a 3x price cut from Opus 4.1 ($15/$75). If you avoided Opus before because of cost, recheck.

The cache read column matters most. At $0.50 per million tokens for Opus, your conversation history costs almost nothing to re-send each turn.

Cache writes cost 25% more than normal input. You pay that once when the cache is created. After that, every read is 90% off. Stay in one session and the math works. Restart often and you keep paying the write cost.

Opus 4.6 and Sonnet 4.6 have flat pricing across the full 1M context window. A 900K-token request costs the same per token as a 9K request.

Older models (Sonnet 4.5, Sonnet 4) charged 2x above 200K tokens. That doubled your cost when sessions got long. Current models don't have that cliff.

This means long sessions don't suddenly get more expensive as they grow. The cost grows in a straight line. With caching, a 170-turn Opus session can cost $21 instead of $168.

It depends on your plan.

Max and Team Premium default to Opus 4.6. Pro and Team Standard default to Sonnet 4.6. You can override this with --model or ANTHROPIC_MODEL. Claude Code may also fall back to Sonnet if you hit usage limits on Opus.

On the API, model choice hits your wallet directly. Sonnet cache reads are $0.30/MTok versus $0.50 for Opus. That's 40% less on the biggest cost. Big refactors benefit from Opus. Simple edits and searches work fine on Sonnet.

Haiku 4.5 is fast and cheap. But Claude Code needs strong instruction-following to run its agentic loop, so most people only use Haiku in wrapper tools.

Claude's thinking tokens are summarized before you see them. But you're billed for the full amount.

I measured this across 30 API calls:

You're paying for 15-17% more output tokens than you can see. At Opus rates, that's about $0.005 per request. Small per request. Adds up over a long session.

Users in GitHub issue #31585 report the gap reaching 3-10x on hard reasoning tasks at higher effort. A code review is moderate. A multi-step architecture decision probably generates much more invisible reasoning.

You can see it in your logs. Check ~/.claude/projects/ for JSONL files:

The thinking field is empty. The signature proves tokens were used. You paid for reasoning you can't read, can't audit, and can't find in your logs.

This isn't a bug. It's how summarized thinking works. But it means your real cost per turn is higher than what you see.

Token usage visibility is a highly requested feature in Claude Code's issue tracker.

You can't fix what you can't measure. Right now, you can't measure this.

Claude Code has an effort setting: low, medium, or high. It controls how much Claude thinks before answering. Toggle it with /effort.

Here's what each level costs. I measured across 30 API calls:

The cost per request barely changes. The speed changes by 3.5x. High takes three times longer for almost the same bill.

Quality? Same across all three in my tests. Anthropic's SWE-bench data shows 76% fewer output tokens at medium versus high. Same task completion. The model just thinks more efficiently at medium.

Until v2.1.68, Claude Code defaulted to high on Opus 4.6. Users on Reddit reported burning through Max limits 10x faster than on Opus 4.5. Anthropic changed the default to medium.

If you're on a subscription, effort is the biggest knob you have. Not because of cost per request. Because of how fast you burn through your ceiling.

Caching keeps Claude Code cheap. Breaking the cache makes turns expensive. Here's what breaks it.

The cache has layers: tools → system prompt → messages. A change at any layer breaks that layer and everything below.

Breaks the entire cache:

Breaks system + message cache:

Breaks on time:

Does NOT break the cache:

Don't switch models mid-session. Don't toggle MCP servers while working. Edit CLAUDE.md between sessions, not during. If you step away for five minutes, the cache expires on its own.

The full details (KV cache, attention layers, prefix ordering) are in the prompt caching deep dive.

60-min video lesson + CLAUDE.md starter kit. Yours when you subscribe.

Two paths.

Subscription (Pro / Max): flat monthly fee, usage ceiling. Anthropic absorbs the cost swings.

API: every token billed, no ceiling on usage or your bill.

Some users go through OpenRouter. That's API billing through a middleman. You don't get subscription pricing.

Picking wrong costs real money. Here's how to tell.

Full breakdown from one of my Opus 4.6 sessions — 170 turns of brainstorming and writing:

33 million input tokens versus 31 thousand output. That's 1,000 to 1.

Even at 90% off, input dominated: $20.18 out of $20.97 (96.2%). Output for the whole session was $0.79. Less than a dollar.

Input per turn grew 5.7x from the first five turns to the last five. Every turn re-sends the whole history. But at 98% cache hits, the growth barely showed up on the bill.

Turn-by-turn averages across multiple sessions:

Compacts are expensive because they break the cache. The conversation resets, a new cache gets written, and the next few turns pay full input price.

Andrej Burkov shared his API usage on X. About $0.80 per request, hundreds per day. That's roughly $80/day, or $2,400/month. Max costs $100/month. 24x cheaper for his usage level.

That's extreme. Burkov is a heavy ML researcher. But it shows the ceiling structure. Once your API bill passes ~$100/month, Max 5x saves money.

The blog ksred.com tracked a project that used about 10 billion tokens. API value: $15,000. Cost on Max: $800. That's 93% less.

The $800 is several months of Max. The $15,000 is what the same work would cost at API rates. For big software projects, subscription pricing isn't a little better. It's a different scale.

Say you run three sessions per day: morning (30 turns), afternoon (60 turns), evening (20 turns). That's 110 turns/day, about 3,300/month.

At $0.11/turn mid-session: $363/month. Each session restart adds about $0.60 of warm-up cost. That's ~$50/month extra.

Total API cost: ~$413/month. Max 5x: $100/month. You save $313/month. That's $3,700/year.

That's not a power user. That's a normal day of work.

The rough threshold is ~$100/month of API usage. Above that, Max 5x probably pays for itself. We can't know exactly, because Anthropic doesn't publish the hard limits behind "5x." Below $40, Pro is enough.

Anthropic's own data: the average developer spends ~$6/day on API. That's ~$180/month. Well above the Max 5x price.

Anthropic now offers extra usage on Pro and Max. When you hit your limit, you don't get blocked. Instead, you keep going at API rates.

You prepay funds and set a spending cap. Usage beyond your plan limit bills at the same prices in the API table above.

This changes the decision. You can start on Pro. Stay within limits most days. Pay API rates only when you overflow. No need to commit to Max or API upfront. Works for both Claude.ai and Claude Code.

We don't know what Anthropic pays for subscription usage on their own hardware. The "5x Pro limits" label suggests a soft usage model, not a hard token budget. If a lot of users started hitting 20x Max every single day, pricing could change. These numbers are from March 2026.

API users: run /cost to see token usage and estimated cost for the current session.

Subscribers (Pro, Max, Team): run /stats instead. /cost tracks API billing, not subscription usage.

Three things affect your costs beyond your plan:

There's a 10x cost difference between CLAUDE.md at the project root versus .claude/rules/. Root placement gets injected into every tool call. It can eat 46% of your context window on rules alone. The .claude/rules/ path only loads when needed.

The most expensive moment in a session is right after a compact. The new summary gets re-cached over several turns. On the API, each compact costs about $0.50-$1.00 in restart overhead. Finish the task first, then compact.

Caching rewards long sessions. Each cold start re-pays the cache write cost. One 80-turn session costs less per turn than four 20-turn sessions doing the same work.

You use Claude Code for daily work. Maybe an hour a day, some longer sessions mixed in. You sometimes hit limits but not always. Default model is Sonnet 4.6. Right entry point for most developers. Turn on extra usage if you want overflow protection.

Multiple long sessions per day. Claude Code is core to your work, not a side tool. Default model is Opus 4.6. The extra $80/month buys you the freedom to stop worrying about limits.

Claude Code 8+ hours a day. Or heavy tasks — big migrations, long research sessions — that burn through 5x limits.

You're building on top of Claude Code. A script, an automation, a custom tool. You want to see exactly what each session costs. The trade-off: no ceiling. A runaway script can rack up a real bill.

Both Team tiers include Claude Code.

You can mix Standard and Premium seats. Minimum 5 seats, up to 150.

For a 5-person team needing heavy usage: Team Premium costs $500-625/month depending on billing. Five individual Max 5x subs cost $500/month. Premium costs about the same but adds the admin controls companies need.

Enterprise is usage-based. $20/seat/month billed annually, plus usage at standard API rates. No per-seat limits. You pay for what you use. Available self-serve or through sales. Admins can set spending limits per org and per user.

No. You need at least Pro ($20/month) or an Anthropic Console account with API credits. The free Claude.ai tier does not include Claude Code.

Pro is $20/month with Sonnet 4.6. Max is $100/month (5x) or $200/month (20x) with Opus 4.6. The difference: usage limits and default model.

Pro: $20 ($17 annual). Max 5x: $100. Max 20x: $200. Team Standard: $25/seat ($20 annual). Team Premium: $125/seat ($100 annual). Enterprise: $20/seat + usage at API rates. On the API, Anthropic says the average developer spends ~$6/day. That's ~$180/month.

For heavy users, yes. The ksred.com case showed 93% savings versus API pricing. Burkov's data showed 24x savings. The rough breakeven is ~$100/month in API usage. If you're hitting Pro limits often, the upgrade pays for itself.

Under ~$50/month API usage: Pro is cheaper. $50-100: Pro with extra usage, or Max 5x. Over $100: Max almost always wins.

Yes. $20/month includes full Claude Code access with standard usage limits.

Usage limits and price. 5x at $100/month, 20x at $200/month. Max 20x is for all-day sessions or heavy automation.

You can reach Claude models through OpenRouter. But that's API billing through a proxy. You don't get subscription pricing. You still need a Claude subscription or Console key to run Claude Code itself.

Yes, both tiers. Team Standard ($25/seat) includes Claude Code with Sonnet 4.6. Team Premium ($125/seat) includes Claude Code with Opus 4.6 and 5x the usage.

I write about Claude Code internals every week - context windows, hooks, MCPs, how things actually work.