Claude Code is not a separate product with its own price tag. Anthropic bundles it into every paid Claude plan, and you can also run it on the API and pay per token. The practical numbers:
- Individuals: $20/month on Pro (or $17/month billed annually), $100/month on Max 5x, $200/month on Max 20x.
- Teams: Claude Code needs a Team Premium seat at $125/seat/month (or $100 annual). Standard seats do not include it.
- Enterprise: $20/seat/month plus usage billed at API rates.
- Pure usage (API): pay per token, roughly $1 to $10 per million input tokens depending on the model, with output running about 5x input.
Real billing lands well above the sticker for heavy agentic work. Anthropic reports enterprise deployments average around $13 per developer per active day, or $150 to $250 per developer per month, with 90% of users staying under $30 per active day.
The biggest lever on that bill is model choice and routing, not the plan you pick. Route routine tasks to a less expensive model, keep Opus for the hard reasoning, and the bill drops without much change in output quality. That is the thread this guide follows.
Claude Code pricing at a glance
| Plan | Starting price | Best for | Claude Code included? |
|---|---|---|---|
| Free | $0 | Casual Claude use | No |
| Pro | $20/mo, or $17/mo annual | Daily individual coding | Yes |
| Max 5x | $100/mo | Heavy individual coding | Yes |
| Max 20x | $200/mo | Power users in the terminal all day | Yes |
| Team Standard | $25/seat/mo, or $20 annual | Teams of 5 to 150 | No (Premium only) |
| Team Premium | $125/seat/mo, or $100 annual | Teams needing Claude Code + governance | Yes |
| Enterprise | $20/seat + usage | Large organizations | Yes |
| API | Pay per token | Programmatic / agentic use | Yes (at API rates) |
Prices change. Anthropic updates the rate card at claude.com/pricing, so check there for the live figures before you commit a budget. The structure above holds across the sources reviewed in June and August 2026.
How Claude Code billing works
Anthropic sells Claude Code as part of its subscription plans, bundled with Claude chat and Claude Cowork. One subscription covers all three, and they draw from a single shared usage allowance.
Two consequences follow, and both surprise new users.
First, your Claude Code sessions count against the same limits as your browser chat. Spend the morning in the terminal and part of the afternoon chatting, and both eat the same five-hour session cap and weekly cap. Hitting the ceiling in the terminal means you have burned capacity for chat too.
Second, the per-token cost of Claude Code through a subscription is much lower than the same usage on the API, until you reach the plan limit. Past that limit you either wait for the reset or buy usage credits, which bill at standard API rates. So the "unlimited" impression of a flat plan is real only within the caps.
The Free plan does not include Claude Code at all. The least expensive legitimate path to try it is one month of Pro at $20.
What each plan actually gives you
Pro is the entry point for using Claude Code. At $20/month (or $17/month billed annually), a single user gets Claude Code in the terminal, plus Claude on web, desktop, and mobile, plus Claude Cowork, covering all models in the lineup. Light to moderate users, a few hours a day on Sonnet, usually stay inside Pro limits. Heavy Opus use on large repositories hits caps quickly, and those users need Max.
Max 5x costs $100/month and gives 5x the Pro capacity per five-hour session. Move to it if you regularly hit the Pro limits during the workday, especially on multi-step coding tasks in large repos.
Max 20x costs $200/month, or about $6.67 per day, and gives 20x Pro capacity. It wins on the math for sustained Opus use, because the API equivalent at standard rates runs well past $200 for daily heavy agentic work. Choose it when Claude Code is your primary tool for several hours a day.
Team requires a minimum of 5 seats and tops out at 150. This is where Claude Code access gets selective. Standard seats at $25/seat/month include SSO, domain capture, and admin tools, but do not include Claude Code. Premium seats at $125/seat/month include it with 5x the session usage. Organizations with more than 150 seats move to Enterprise.
Enterprise costs $20/seat/month plus usage at API rates. The access and the usage are billed separately, which means light users do not subsidize heavy ones. You get role-based access control, SCIM provisioning, audit logs, a compliance API, and HIPAA-ready options. Larger contracts support invoicing and AWS Marketplace procurement.
API (pay as you go) is the path for developers building agents or integrations that call Claude programmatically, or running intensive sprints. There is no monthly fee, no ceiling, and no seat. You pay the standard per-token rate for whatever the sessions consume.
Claude Code on the API: per-token rates
When Claude Code authenticates with an API key or a Console account, it bills at standard API rates. Anthropic prices by the million tokens, with four tiers in common use:
| Tier | Input (per MTok) | Output (per MTok) | Cache read |
|---|---|---|---|
| Haiku | $1 | $5 | ~$0.10 |
| Sonnet | $3 | $15 | ~$0.30 |
| Opus | $5 | $25 | ~$0.50 |
| Frontier top tier | $10 | $50 | ~$1 |
Three things stand out in that table.
Output costs five times input on every tier. The most expensive tokens you buy are the ones Claude writes, which is why letting responses run long is the fastest way to inflate a bill.
Cache reads cost about a tenth of the base input rate. For agentic coding, where the same codebase context loads over and over, prompt caching turns a repeated $3-per-million read into a $0.30 one. Reorder your system prompt so stable content leads, and the cache pays off after a single hit.
The model tiers span a 10x spread on both input and output, Haiku to the top tier. That spread is the entire game of cost control, and nobody exploiting it is running everything on Opus.
One caveat on model naming: the recognizable model names (for example Sonnet, Opus, Haiku) change as Anthropic ships releases, and a couple of tiers carry temporary introductory rates. The Claude Code docs and claude.com/pricing list the current model names. Treat the per-token tier above as the durable figure.
Hidden costs and billing traps
The headline prices are clear. A handful of usage patterns inflate the real bill, and knowing them before you commit saves money.
Limits reset weekly, not monthly. Pro and Max impose weekly caps on top of per-session limits. Blow through the week's allocation by Wednesday and you wait for the session anniversary to keep coding on the subscription.
Sessions run five hours each. Every session has its own five-hour ceiling. Multiple sessions can run in a week, but each window caps independently, so long-lived sessions hit the wall faster than they feel like they should.
Opus burns capacity about 1.7x faster than Sonnet. The same ratio that makes Opus pricier on the API applies to how quickly it consumes subscription capacity, so Opus-heavy sessions hit the weekly wall sooner.
The ANTHROPIC_API_KEY trap. If you have an Anthropic API key set as an environment variable, Claude Code authenticates with that key and bills your API account at per-token rates, even when you hold a subscription. Check your billing source with the /status command inside Claude Code. To stay on the subscription, run claude logout and re-authenticate with your Pro or Max credentials.
API-only line items. Running Claude Code through the API adds costs that subscriptions absorb: web search at about $10 per thousand searches, and code execution around $0.05 per container-hour after the first 50 free hours per day. These do not appear on subscription plans, so they often slip past on a hybrid setup.
Team usage credits are uncapped by default. Team plans let members buy usage credits when they exceed seat limits. Those bill at API rates and have no default ceiling, so set spend controls early.
What teams actually pay
Enterprise figures from Anthropic's own cost documentation put real-world spend in a useful band: 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.
Those are averages across many setups, driven by model choice, codebase size, and whether teams run parallel agent instances and automation. A small pilot with the /usage command in Claude Code and Anthropic's spend reports gives you a baseline for your own team before rolling out wider.
The pattern that separates the high spend from the low spend is not the plan. It is how much work runs on the top-tier model versus how much runs on a model suited to the task. That holds for both subscriptions and the API, and it is the lever the rest of this guide is about.
How to cut Claude Code cost
The pricing is what it is. Your organization controls how much of it you burn. These levers, roughly in order of impact, work on both subscriptions and the API.
1. Route each task to the smallest model that can do it. The 10x spread between the entry tier and the top tier is the single largest decision you make. Classification, extraction, and routine refactors do not need a frontier model. Keep the strongest model for hard reasoning and open-ended architecture work. Tiered routing by task complexity is the biggest saving most teams can make, and it costs nothing to try.
2. Cache aggressively, then verify the hits. Claude re-reads your conversation history on every request, and with prompt caching it pays the discounted cache-read rate instead of the full input rate. Keep stable content such as system prompts and project context at the front of the prompt, and monitor the cache hit rate. A silent cache miss re-bills that content at the full input price, roughly 10x the cached rate, and nothing notifies you. On agentic coding this lever alone frequently halves input spend.
3. Batch whatever can wait. Anthropic's Batch API cuts both input and output rates by roughly half for asynchronous work completed within a day. Nightly code analysis, bulk refactors, and documentation generation belong in the queue rather than in interactive sessions.
4. Constrain output length. Instructing brevity and setting response limits attacks the most expensive tokens you buy. An unconstrained long answer is the priciest line on the bill.
5. Control parallel agents and context size. Every parallel agent instance and every long-lived session keeps sending the full conversation with each request. Keep the context small, compact large sessions instead of letting them balloon, and start fresh with /clear when you do not need the history. Each active agent keeps consuming tokens until it exits, so cap the number of teammates running at once.
6. Watch the rate changes. A couple of tiers run on introductory rates that expire. Forecast your next quarter on the durable rate, not the promotional one, so the budget does not break the month after the discount ends.
7. Give every dollar an owner. Untracked token spend grows on its own. When nobody can attribute a cost to a team, a feature, or a customer, nobody is accountable for trimming it. Tooling that maps spend to the people and products that generate it turns the other six levers from advice into practice.
How you route depends on scale. A solo developer switches models by hand. A team running thousands of agentic calls a day cannot, which is why the routing decision is the one worth automating.
Worked example: what a day of coding actually costs
A concrete calculation shows where the money goes. The assumptions below are the kind of real usage teams see; swap in your own token counts and the arithmetic holds.
Take a developer running 20 agentic coding sessions a day. Each session loads a 100,000-token codebase context, mostly cached, and generates 10,000 output tokens. Two scenarios, same workload, different model.
Sonnet tier ($3 input, $15 output, $0.30 cache read per million tokens):
- Cache reads: 90,000 tokens at $0.30/MTok = $0.03
- Fresh input (new turns and code changes): 10,000 tokens at $3/MTok = $0.03
- Output: 10,000 tokens at $15/MTok = $0.15
Per session comes to about $0.21. Twenty sessions is $4.20 a day, or roughly $88 a month on a 21-working-day cycle.
Same workload on Opus tier ($5 input, $25 output, $0.50 cache read):
- Cache reads: 90,000 tokens at $0.50/MTok = $0.05
- Fresh input: 10,000 tokens at $5/MTok = $0.05
- Output: 10,000 tokens at $25/MTok = $0.25
Per session comes to about $0.35. Twenty sessions is $7 a day, or roughly $145 a month. The same 20 sessions cost about 1.6x more on Opus, with no difference in the work done.
The scaling is where it bites. Multiply that by a team of 50 developers and the Sonnet bill alone is north of $4,000 a month. Route even half of those sessions to a less expensive model, apply caching properly, and cap output, and the savings accumulate fast.
Subscription vs API: which costs less
The flat plan is effectively a discount for heavy use, and the API wins for light or spiky use. The break-even depends on volume. The table below uses standard Sonnet rates ($3 input, $15 output per million tokens) with prompt caching and batch discounts ignored, so real API bills are often lower than shown. Treat it as the shape of the decision, not a quote.
| Monthly usage profile | Input tokens | Output tokens | API cost | Cheaper option |
|---|---|---|---|---|
| Light: occasional chat and small tasks | 5M | 1M | $30 | Pro ($20) |
| Moderate: daily coding sessions | 60M | 4M | $240 | Max 20x ($200) |
| Heavy: agentic workflows all day | 200M | 10M | $750 | Max 20x, by roughly 4x |
| Very heavy: parallel agents | 500M | 25M | $1,875 | Max 20x, by roughly 9x |
The pattern holds: subscriptions are flat-rate arbitrage for heavy interactive use, and the meter wins for light use and for any production workload that needs per-request cost attribution, because a subscription cannot serve your customers.
Two caveats. First, caching and batching shrink the API column, sometimes dramatically, so a heavy user running everything through a well-cached API can beat these numbers. Second, the subscription caps still apply: hit the weekly limit and you are buying usage credits at API rates anyway.
Which Claude Code plan should you choose
Pro fits the individual developer doing daily coding who hits the limits only once or twice a week. It is the least expensive honest way into Claude Code.
Max 5x fits the individual who regularly runs out of Pro mid-workday or works on large repositories with multi-step tasks.
Max 20x fits the power user who treats Claude Code as the primary tool and runs it for hours daily, especially with Opus. At roughly $6.67 per day it beats the API rate for that sustained load.
Team Premium fits organizations of 5 to 150 that need Claude Code plus SSO, centralized billing, and admin controls. Remember Standard seats do not include Claude Code, so factor the higher seat price into the decision.
Enterprise fits large organizations, regulated industries, or anything requiring RBAC, SCIM, audit logs, and custom procurement.
API pay as you go fits teams building agents and integrations, or those with spiky usage that a flat subscription cannot absorb. It also gives you per-request cost attribution, which any production application needs because a subscription cannot serve your customers.
Frequently asked questions
Is Claude Code free? No. It requires a paid plan (Pro, Max, Team Premium, or Enterprise) starting at $20/month, or you pay per token through the API. The Free plan does not include it.
How much does Claude Code cost per month? $20 on Pro monthly, or $17 billed annually. Heavier tiers run $100 (Max 5x), $200 (Max 20x), and $100 to $125 per seat (Team Premium). Enterprise is $20 per seat plus usage.
Does Claude Code count against the same limits as chat? Yes. Claude Code, chat, and Cowork share one usage allowance across every paid plan, so coding sessions consume the same five-hour and weekly caps as browser chats.
Can I use Claude Code with API credits instead of a subscription? Yes. With an API key or Console account it bills at standard per-token rates. In practice that means you can choose the billing model per setup, but be deliberate about which one a given machine uses.
Why is Claude Code so expensive? The bill usually traces to output tokens (5x input on every model), thinking tokens billed at output rates, and agentic workloads consuming tokens in parallel. Model routing, caching, and batching are the levers that bring it down without changing the workload.
The takeaway
Claude Code's sticker price is modest. The real cost is decided by how you use it: which model handles each task, how much you let it write, how well you cache, and whether anyone watches the spend. Control those and a $200 plan or an API bill stays under control. Ignore them and the meter runs on its own.
The routing decision is the one worth automating at scale. Send each task to the model that fits it, cap the budget, and the cost stops being a surprise. That is the move that turns Claude Code from a line item you dread into a predictable one.