Claude Code Pricing Explained: Plans, Token Costs, and How to Cut Spend

The two ways Claude Code is billed

Before any number means anything, you have to know which meter is running. Claude Code charges by API token consumption underneath, but how that reaches your card depends on how your developers sign in.

• Subscription seats (Pro, Max, Team, Enterprise). Usage draws from a per-seat allowance that resets on a five-hour rolling window and a weekly window. That allowance is shared with Claude chat and Cowork, so a heavy chat day eats into the same bucket as coding.
• Pay-as-you-go (Claude Console or a cloud provider). Every token is billed to a workspace or your cloud account at list API rates. There is no allowance and no cap unless you set one.

A team can mix both: each developer is metered according to the method they authenticated with. The plan table below is the subscription side; the token table after it is what actually accrues underneath.

Claude Code plans and prices

• Subscription allowances are shared across Claude Code, Claude chat and Cowork — the same five-hour and weekly windows cover all three.
• Annual billing lowers the effective monthly price (Pro $20 → $17, Team Standard $25 → $20, Premium $125 → $100).
• On Amazon Bedrock, Google Vertex or Microsoft Foundry, Claude Code is billed per token to your cloud account, and spend controls live in your cloud console — not in Anthropic’s.

For the usage limits behind each plan — the five-hour window, the weekly cap and what happens when you hit them — see Claude Code limits explained.

The token prices behind every plan

Whichever plan you are on, the underlying cost is per million tokens (MTok) and depends entirely on the model. This is the single biggest lever on your bill.

• Batch processing is 50% cheaper than real-time for work that can wait.
• Cached input is ~10x cheaper to read than fresh input — which is why a long, warm session is far cheaper per message than a cold one.
• US-only inference is billed at 1.1x standard, and Opus 5.5 fast mode is 2x — small multipliers that add up across a fleet.

Choosing the right tier for each task is a cost decision in its own right; we break the trade-offs down in Opus vs Sonnet vs Haiku: a cost-vs-capability routing guide.

So what does a developer actually cost?

Across enterprise deployments the average works out to about $13 per developer per active day and $150–250 per developer per month, and stays under $30 a day for roughly 90% of users. The long tail is real, though: one developer running Opus all day across multiple repositories can spend several times the median.

Two habits explain most unexpectedly high bills: long sessions that are never cleared (so every message re-sends the whole conversation), and Opus left as the default model when Sonnet would have done the job. Both are fixable, and both are easier to catch when you can see spend per developer. For a deeper breakdown by agent, see what AI coding agents actually cost per developer.

How to cut Claude Code spend

The levers, in rough order of impact:

1. Match the model to the job. Sonnet handles most coding well at a fifth of Opus output cost; reserve Opus for architecture and multi-step reasoning, and push simple subagent tasks to Haiku.
2. Lean on prompt caching. Repeated system prompts and file context read from cache at ~10x less. Keeping a session warm within its cache lifetime (one hour on a subscription, five minutes on the API) avoids re-paying for the same context — the real cost math is here.
3. Clear between unrelated tasks. A fresh session stops you paying to re-send stale context on every message.
4. Batch what can wait for the 50% discount, and keep agent teams small — each teammate runs its own context window.
5. Make spend visible per developer, so you can act on the two outliers instead of guessing across the whole team.

Want one cost number per developer across Claude Code, Cursor and Codex — not three dashboards?

TrueFoundry AI Gateway

Where the bill actually shows up

The hardest part of Claude Code pricing is not the rate card — it is seeing and capping spend once thirty developers are using it. Where you do that depends on how they sign in.

On the subscription plans the controls are reasonable. On the Console and especially on cloud providers, per-developer attribution is not built in — which is exactly the gap an AI gateway fills.

Cutting spend with the TrueFoundry AI Gateway

Routing Claude Code through the TrueFoundry AI Gateway puts every completion on a path you control, whichever plan or provider sits behind it. That gives you four things the native billing does not, all at once:

• Per-developer attribution. Every request resolves to an individual, so spend reports and rate limits mean something — covered in cost tracking for Claude Code.
• Model policy. Cap which models a developer may reach, so Opus is a deliberate choice rather than an accidental default.
• One cost view across tools. Claude Code, Cursor and Codex land in the same dashboard — one bill instead of four.
• Spend limits and governance that hold without developer cooperation, as in Claude Code governance with an AI gateway.

If you are choosing where to route it, we compared the options in the best AI gateway for Claude Code.

A worked example

Thirty engineers on Max 20x at $200/mo is $6,000/mo in subscriptions — predictable, but with no per-developer visibility and no model control. Move the same team onto Console billing behind the gateway and the picture changes: you see that three developers drive 60% of token spend because Opus is their default, you set a model policy that routes routine edits to Sonnet, and the monthly number drops while the two genuine power users keep Opus. The subscription hid the distribution; the gateway surfaced it.

The honest limit: a gateway governs model choice, attribution and spend. It does not change Anthropic’s per-token rates — it just makes sure you only pay them where they earn their keep.

Ready to see per-developer Claude Code spend in one place?

Book a demo

Gotchas worth knowing

• The subscription allowance is shared. Claude Code, Claude chat and Cowork draw from the same five-hour and weekly windows, so a heavy chat day can throttle coding.
• Cache lifetime differs by plan. It is one hour on a subscription but drops to five minutes on the API and cloud providers — so the same workflow re-pays for context far more often on pay-as-you-go.
• The /usage dollar figure is an estimate computed locally at list price. If your org pays contracted rates, it will not match your invoice unless an admin sets the rate override.
• Cloud-provider usage is invisible to Anthropic’s dashboards. On Bedrock, Vertex or Foundry you get per-user attribution only through OpenTelemetry or an LLM gateway.
• Long idle sessions still cost money — scheduled tasks and background check-ins re-send your full context on their interval even when you are not typing.

Subscription or pay-as-you-go: which is cheaper for you

The two billing models cross over at a predictable point, and knowing roughly where saves a lot of guesswork. A subscription seat is a flat fee for an allowance; pay-as-you-go is a variable bill for exactly what you burn. For a developer whose usage sits comfortably inside a Max seat’s allowance, the subscription is both cheaper and predictable. For a developer who barely touches it, a Pro seat or light API usage wins. The trouble starts at the two tails: a heavy user on Pro hits limits and loses time, while a light user on Max 20x pays $200/mo for a fraction of the allowance.

A rough way to decide for a team: if most developers are steady daily users, buy seats sized to the median and handle the heavy tail with usage credits; if usage is spiky or concentrated in a few people, meter everyone on the API behind a gateway and set per-developer spend limits so the spiky users are capped rather than throttled. The one combination to avoid is buying everyone the top seat “to be safe” — that pays the maximum for the median, which is exactly backwards.

What actually drives the bill

Token spend is not uniform across a session; a handful of behaviours account for most of it, and each has a direct fix:

Notice that four of the five are about context size, not request count — which is the single most counter-intuitive thing about agentic coding cost. A one-line question in a session that has been open all day can cost more than a fresh, focused task, because the one-liner drags the whole day’s context along with it. The real cost math on caching makes the warm-vs-cold difference concrete, and model routing is covered in the Opus vs Sonnet vs Haiku guide.

Related reading

• Claude Code Limits Explained — the usage windows behind each plan
• Cost Tracking Claude Code with the TrueFoundry AI Gateway — per-developer attribution in practice
• Centralising Cost Control for AI Coding IDEs — one cost view across Claude Code, Cursor and Codex
• Opus vs Sonnet vs Haiku: a Cost-vs-Capability Routing Guide — the biggest single lever on your bill
• Claude Prompt Caching: the Real Cost Math — when caching saves money and when it does not

Conclusion

Most explanations of Claude Code pricing stop at the plan table. The plan is the easy half. The half that decides your actual bill is underneath it: which model each request uses, how much context it carries, whether the cache is warm, and whether you can see any of that per developer. Those are not line items on a pricing page — they are configuration choices, and each one is a lever.

A subscription makes the number predictable. A gateway makes it controllable — model policy, per-developer attribution, and spend limits that hold across every coding tool your team uses. That is the difference between knowing what Claude Code lists at and knowing what it costs you.

Put your coding agents behind one cost and control plane.

Start free on TrueFoundry