Engineering
Claude Code Cost in 2026: Plans, API Prices, Per-Developer Tracking
See what Claude Code costs in 2026 across plans, API rates and cloud billing, what drives the bill, and how to track spend per developer with Nautili.

TL;DR
- Claude Code cost depends on how you pay. A subscription seat is a flat monthly price with usage limits, an API key is billed per token, and a cloud provider bills per token on your cloud invoice.
- Anthropic's own estimate across enterprise deployments is around $13 per developer per active day and $150 to $250 per developer per month, with 90% of users below $30 per active day.
- Six things drive the bill: model, context size, session length, subagents, thinking, and caching. Clearing context, matching the model to the task, and keeping agent teams small drive the biggest reductions.
- Claude Code's built-in views show one developer or one billing path. To see who spent what across a team, route Claude Code through a gateway such as Nautili, which attributes every request to a team and project, and to a person when the developer signs in with a Claude subscription login. On a plain
ANTHROPIC_API_KEYthe developer is blank unless the request carriesX-Dz-User, which Claude Code can send throughANTHROPIC_CUSTOM_HEADERS. - Limits need an issued key in place of each developer's own login: a team budget can be pooled across the whole group, and model allowlists refuse a request before it reaches the provider.
Suppose we have an engineering lead who has to decide whether twelve developers on Pro seats should move to a Team plan or to API keys. The right answer depends on how much each person uses, so the sections below give the real prices first, then show what moves the number and how to measure it per person.
What Claude Code Costs in 2026
Claude Code has no separate price tag. You pay for it through a Claude subscription, through an API key billed per token, or through a cloud provider such as Amazon Bedrock. Anthropic states that Claude Code charges by API token consumption and that per-developer cost varies with model choice, codebase size, and usage patterns such as running several instances or automation.
The three paths behave differently:
| Subscription seat | API key (Console) | Cloud provider | |
|---|---|---|---|
| How it is billed | Subscription seatFlat monthly price per seat | API key (Console)Per token, at API rates | Cloud providerPer token, on your cloud bill |
| What limits usage | Subscription seatFive-hour and weekly usage limits | API key (Console)Workspace spend limits | Cloud providerYour cloud's budget controls |
| Where spend is visible | Subscription seatAdmin analytics and spend report | API key (Console)Console usage page and dashboard | Cloud providerYour cloud billing console |
Claude Code Subscription Plans With Current Prices
These are the prices shown on Anthropic's plans page as of November 4, 2026. Anthropic notes that prices and plans are subject to change.
| Plan | Annual billing | Monthly billing | Claude Code included |
|---|---|---|---|
| Free | Annual billing$0 | Monthly billing$0 | Claude Code includedNo |
| Pro | Annual billing$17 per month, billed up front as $200 | Monthly billing$20 | Claude Code includedYes |
| Max | Annual billingNot offered | Monthly billing$100 | Claude Code includedYes |
| Ultra | Annual billingNot offered | Monthly billing$200 | Claude Code includedYes |
| Team, Standard seat | Annual billing$20 per seat | Monthly billing$25 per seat | Claude Code includedYes |
| Team, Premium seat | Annual billing$100 per seat | Monthly billing$125 per seat | Claude Code includedYes |
| Enterprise | Annual billing$20 per seat plus usage at API rates, 20 seat minimum | Monthly billingNot offered | Claude Code includedYes |
On Pro and Max, Claude and Claude Code draw from the same usage limits, a five-hour session limit and a weekly limit, so chat and coding sessions count against one pool. Ultra has no five-hour limit for verified accounts, and Max and Ultra both include Fable for up to half of the weekly limit (on Pro, Fable bills to usage credits). A developer who hits a limit can wait for the reset, turn on usage credits (billed at standard API rates), or move to a higher tier.
One detail catches teams out: an ANTHROPIC_API_KEY environment variable overrides the subscription. Claude Code then uses that key, and you are charged API rates instead of using the plan's included usage.
Claude Code API Costs per Million Tokens
For an API key, cost is tokens multiplied by price. These are the current rates from Anthropic's API pricing page as of November 4, 2026, in US dollars per million tokens.
| Model | Base input | 5-minute cache write | 1-hour cache write | Cache read | Output |
|---|---|---|---|---|---|
| Claude Fable 5.1 | Base input$10 | 5-minute cache write$12.50 | 1-hour cache write$20 | Cache read$0.25 | Output$50 |
| Claude Opus 5.5 | Base input$4 | 5-minute cache write$5 | 1-hour cache write$8 | Cache read$0.20 | Output$20 |
| Claude Sonnet 5.5 | Base input$2 | 5-minute cache write$2.50 | 1-hour cache write$4 | Cache read$0.10 | Output$10 |
| Claude Haiku 5.5 (prompts up to 100,000 tokens) | Base input$0.10 | 5-minute cache write$0.125 | 1-hour cache write$0.20 | Cache read$0.01 | Output$0.50 |
| Claude Haiku 5.5 (prompts over 100,000 tokens) | Base input$0.50 | 5-minute cache write$0.625 | 1-hour cache write$1 | Cache read$0.05 | Output$2.50 |
Opus costs twice what Sonnet does on both input and output, and Fable 5.1 costs 2.5 times Opus. Fable 5 has the same input and output prices but a $1 cache read, and Fable 5.1 is selectable with /model fable and can bill to usage credits.
A cache read costs 5% of the base input price on Opus 5.5 and Sonnet 5.5, 10% on Haiku 5.5 and 2.5% on Fable 5.1, while a cache write costs 1.25 times input for five minutes or 2 times for one hour. Because Claude Code writes cache every turn, a session that keeps its cache warm is far cheaper than one that keeps reprocessing its history.
Opus 5.5, Sonnet 5.5 and Fable 5.1 include the full 1M token context window at standard pricing, while Haiku 5.5 charges higher rates for prompts over 100,000 tokens.
What Drives Claude Code Cost Up or Down
Six things drive the bill, and each one shows up as a different line in the token count:
- Model: Opus costs twice Sonnet per token, Fable models cost 2.5 times Opus, and a switch to Opus or Fable also applies to subagents that inherit the session's model. Opus 5.5 is the shipped default on subscription plans, the Anthropic API, Bedrock and Google Cloud (Foundry defaults to Sonnet 4.5), and Anthropic suggests reserving Opus for complex architectural work.
- Context size: Claude Code sends the whole conversation with every request, so a one-line question in a session that has been open all day still reads the full history.
- Session length: Each tool call sends another request carrying its results, and a break longer than the cache lifetime means the next message reprocesses everything.
- Sub Agents and teams: Every subagent sends its own requests, and agent teams use approximately 7x more tokens than standard sessions when teammates run in plan mode.
- Thinking: Extended thinking tokens are billed as output tokens, and the default budget can reach tens of thousands of tokens per request. Thinking cannot be turned off on the 5.5 and Fable models, only lowered with
/effort. - Caching: Prompt caching keeps repeated content at the cache-read rate, and compaction or cache misses rebuild it at a higher price.
How Much Claude Code Costs for Each Developer or Team
Anthropic publishes one planning figure. Across enterprise deployments, the average is around $13 per developer per active day and $150 to $250 per developer per month, with costs below $30 per active day for 90% of users. Anthropic advises starting with a small pilot group to measure a baseline before wider rollout.

The table below multiplies that published average by team size. It is an estimate built from Anthropic's figure, not a quote, and your own spread will be wider.
| Team size | Per active day at $13 | Per month at $150 | Per month at $250 |
|---|---|---|---|
| 10 developers | Per active day at $13$130 | Per month at $150$1,500 | Per month at $250$2,500 |
| 25 developers | Per active day at $13$325 | Per month at $150$3,750 | Per month at $250$6,250 |
| 50 developers | Per active day at $13$650 | Per month at $150$7,500 | Per month at $250$12,500 |
A team that runs long Opus sessions with parallel agents will sit above that range, and a team that clears context and defaults to Sonnet will sit below it.
Subscription, API Key or Cloud Provider for Your Team
Which path is cheaper depends on how heavily each developer uses it, so match the path to the usage pattern:
| If your team | Start with | Why |
|---|---|---|
| Has a few developers with steady daily use | Start withTeam seats | WhyA flat seat price caps the monthly bill, and limits reset on five-hour and weekly windows |
| Runs heavy automation or many parallel agents | Start withAPI key through the Console | WhyPer-token billing has no usage ceiling, and workspace spend limits cap total cost |
| Already buys model access through a cloud account | Start withBedrock, Google Cloud or Foundry | WhySpend sits on the cloud invoice and follows your cloud budget controls |
For API organizations, Anthropic recommends tokens-per-minute limits that shrink per user as the team grows, from 200k to 300k per user for 1 to 5 users down to 25k to 35k for 50 to 100 users, and these limits apply at the organization level, not to individual users.
Where Claude Code Spend Shows Up Today
Anthropic gives you several views, and each covers a slice:
/usageinside Claude Code shows the current session. The dollar figure is computed locally at list price and is an estimate, so the Console is the authoritative bill.- The Claude Console dashboard shows spend per member for API organizations.
- The Teams and Enterprise spend report shows estimated spend per user, but only for usage-credit spend.
- On Amazon Bedrock, Google Cloud's Agent Platform, or Microsoft Foundry, Claude Code sends nothing back to Anthropic, so per-user numbers need OpenTelemetry, Anthropic's self-hosted Claude apps gateway for per-user attribution and spend limits, or an LLM gateway. Nautili is that gateway across every provider, with seats and budgets per person, key or workspace.
The gap is the same in every case. Each view shows one billing path, and none of them ties to a project or a service.
A Cost Control Checklist From Anthropic's Own Guidance
These habits come from Anthropic's cost guidance and cost nothing to adopt:
- Run
/clearbetween unrelated tasks, and use/renamefirst so the session can be resumed later. - Add compaction instructions, for example,
/compact Focus on code samples and API usage, so the summary keeps the parts the next step needs. - Opus 5.5 is the default model on subscription plans and the API, so choose Sonnet deliberately and switch to Opus with
/modelonly for complex reasoning. Setmodel: haikuon simple subagent tasks. - Lower the effort level with
/efforton simple work, since thinking is billed as output and, on the 5.5 and Fable models, can be lowered but not turned off. - Disable MCP servers you are not using with
/mcp, and keepCLAUDE.mdunder about 200 lines by moving workflow instructions into skills. - Keep agent teams small and shut teammates down when their work is done.
The checklist above lowers what each session costs, but it cannot show who is spending or on which project, because every view covered earlier sits on one billing path. Routing Claude Code through a gateway closes that gap: all requests pass through one place, so each one can be recorded and attributed to a person, team and project whichever way the developer signs in. The People page in the Nautili dashboard, shown below, is where that per-developer view appears.
Track Claude Code Cost Per Developer With Nautili

Nautili is an LLM gateway that receives Claude Code requests and records tokens, cost, latency, and cache outcomes for each one, attributing them to an owner. Setup is one environment variable, ANTHROPIC_BASE_URL, pointed at the gateway's Anthropic listener on a self-hosted or Hosted Gateway, while the Shared Gateway needs an issued key. The full walkthrough is in the Claude Code proxy guide, the Nautili coding tools guide and the Claude Code integration page.
The first level of visibility needs no change to how anyone pays. Nautili then gives you:
- Per-developer usage when the developer signs in with a Claude subscription login, with requests grouped into sessions. On a plain
ANTHROPIC_API_KEYthe developer is blank unless the request carriesX-Dz-User, which Claude Code can send throughANTHROPIC_CUSTOM_HEADERS. - Spend splits into provider-attested figures, which come from the provider's ledger and exist only for managed spend, and gateway-reported figures, which the spend page labels as measured by your gateway and which are the only figures for your own credentials.
- Cache behavior per request, so you can see whether long sessions keep paying for repeated context.
This setup tracks usage but does not cap it, and the Claude Code proxy guide explains how subscription traffic is reported.
Attribute Claude Code Spend to Each Team Project
Nautili reads the headers X-Dz-Team, X-Dz-Project, and X-Dz-Env on every request, including base-URL-only traffic, so each request can be tagged whichever way the developer signs in, and X-Dz-Labels accepts any key=value pair you want stored per request.
In Claude Code, you add them through ANTHROPIC_CUSTOM_HEADERS in ~/.claude/settings.json, which keeps the credential out of any repository.
That answers what a team spent last month, which project drives the bill, and how staging compares with production. The Teams page in the Nautili dashboard, shown below, lists each team so its spend can be compared.

Cap Claude Code Spend With an Issued Key
Limits need a credential Nautili controls, which means an issued key in place of each developer's own login, as the Claude Code proxy guide sets out step by step. What it adds for cost control:
- Budgets: A budget binds to a person, a service key, or the team-default guardrail for the whole workspace, and a pooled counter shares one bucket across everyone bound to that guardrail.
- Model allowlists: Restrict a group to Sonnet and Haiku, and Opus requests are refused before they reach the provider.
- Shadow mode: Shadow mode is a gateway-wide setting rather than a per-guardrail one, and every install boots in enforce. Switch the gateway to shadow to record would-denies: traffic on your own credentials goes through, while on an issued key a would-deny still fails with a provider 401, so test in a staging team first.
Only a guardrail in enforce mode refuses requests, whether for a budget or a model allowlist. Because the issued key replaces the claude.ai login, the subscription's usage limits no longer apply to that traffic, and the provider bills the key instead. Decide which developers move to keys before you switch anyone over, and read the governance guide for the full rule set.
The screenshot below shows the Limits step of the guardrail wizard in the Nautili dashboard, where the dollar budget for a group is set before you review and save the guardrail.

Where to Start With Claude Code Cost Tracking
Claude Code cost comes from three places: the plan or API rate you pick, how much each developer runs it, and whether anyone can see the split by person and project. Plans and provider consoles show the total, while issued keys with a monthly cap let you attribute spend to each developer and stop it at a limit you choose.
The easiest way to begin is with one team: move its developers onto issued keys, give each key a monthly cap (budgets need the Pay-as-you-go plan), and run it for a billing cycle. You will see which projects drive the spend and whether the team needs a hard limit or just a clearer view, and because every team already has a Shared Gateway, you can create that first key in the Nautili dashboard today.
FAQs
How much does Claude Code cost per month?
On a subscription, it costs the plan price: $17 to $20 per month for Pro, $100 per month for Max and $200 per month for Ultra, as of November 4, 2026. For an API key, Anthropic's estimate is $150 to $250 per developer per month on average, with wide variation.
Is Claude Code free?
No. The Free plan does not include Claude Code. You need a paid plan, an API key or a cloud provider account.
Is Claude Code cheaper on a subscription or the API?
It depends on usage. A subscription caps your monthly price but limits usage, while the API has no usage ceiling and charges per token. Measure a pilot group before you choose.
How do I check how much Claude Code I have used?
Run /usage inside Claude Code to see session token use and, on a plan, usage bars. The dollar figure is an estimate at list price, so check the Console usage page for the authoritative bill.
How do I see what each developer spends on Claude Code?
Use the Console dashboard for API keys, the spend report for Teams and Enterprise plans, or a gateway that attributes every request across all of them. Nautili does the last one with a single base URL change.
Can Nautili cap spend on a personal Claude subscription?
No. With only the base URL set, the request carries the developer's own credential, so Nautili can track it but not limit it. Budgets need an issued key, and base-URL-only tracking needs a self-hosted or Hosted Gateway because the Shared Gateway refuses subscription tokens.
Is there a Claude plan without a five-hour usage limit?
Yes. Ultra costs $200 per month and has no five-hour session limit for verified accounts, though it keeps a weekly limit and includes Fable for up to half of it, as of November 4, 2026. Max, at $100 per month, keeps both the five-hour limit and the weekly limit.
Written by
Nautili team


