Skip to content

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.

Nautili team

16 min read

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_KEY the developer is blank unless the request carries X-Dz-User, which Claude Code can send through ANTHROPIC_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 seatAPI key (Console)Cloud provider
How it is billedSubscription seatFlat monthly price per seatAPI key (Console)Per token, at API ratesCloud providerPer token, on your cloud bill
What limits usageSubscription seatFive-hour and weekly usage limitsAPI key (Console)Workspace spend limitsCloud providerYour cloud's budget controls
Where spend is visibleSubscription seatAdmin analytics and spend reportAPI key (Console)Console usage page and dashboardCloud 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.

PlanAnnual billingMonthly billingClaude Code included
FreeAnnual billing$0Monthly billing$0Claude Code includedNo
ProAnnual billing$17 per month, billed up front as $200Monthly billing$20Claude Code includedYes
MaxAnnual billingNot offeredMonthly billing$100Claude Code includedYes
UltraAnnual billingNot offeredMonthly billing$200Claude Code includedYes
Team, Standard seatAnnual billing$20 per seatMonthly billing$25 per seatClaude Code includedYes
Team, Premium seatAnnual billing$100 per seatMonthly billing$125 per seatClaude Code includedYes
EnterpriseAnnual billing$20 per seat plus usage at API rates, 20 seat minimumMonthly billingNot offeredClaude 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.

ModelBase input5-minute cache write1-hour cache writeCache readOutput
Claude Fable 5.1Base input$105-minute cache write$12.501-hour cache write$20Cache read$0.25Output$50
Claude Opus 5.5Base input$45-minute cache write$51-hour cache write$8Cache read$0.20Output$20
Claude Sonnet 5.5Base input$25-minute cache write$2.501-hour cache write$4Cache read$0.10Output$10
Claude Haiku 5.5 (prompts up to 100,000 tokens)Base input$0.105-minute cache write$0.1251-hour cache write$0.20Cache read$0.01Output$0.50
Claude Haiku 5.5 (prompts over 100,000 tokens)Base input$0.505-minute cache write$0.6251-hour cache write$1Cache read$0.05Output$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.

Bar chart of Claude Code cost per developer per month: Pro at $20, Team Standard at $25, Max at $100, Team Premium at $125, Ultra at $200, and Anthropic's published API average of $150 to $250.

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 sizePer active day at $13Per month at $150Per month at $250
10 developersPer active day at $13$130Per month at $150$1,500Per month at $250$2,500
25 developersPer active day at $13$325Per month at $150$3,750Per month at $250$6,250
50 developersPer active day at $13$650Per month at $150$7,500Per 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 teamStart withWhy
Has a few developers with steady daily useStart withTeam seatsWhyA flat seat price caps the monthly bill, and limits reset on five-hour and weekly windows
Runs heavy automation or many parallel agentsStart withAPI key through the ConsoleWhyPer-token billing has no usage ceiling, and workspace spend limits cap total cost
Already buys model access through a cloud accountStart withBedrock, Google Cloud or FoundryWhySpend 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:

  • /usage inside 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 /clear between unrelated tasks, and use /rename first 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 /model only for complex reasoning. Set model: haiku on simple subagent tasks.
  • Lower the effort level with /effort on 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 keep CLAUDE.md under 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

The People page in the Nautili dashboard, listing each developer with their Claude Code requests, tokens and spend.

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_KEY the developer is blank unless the request carries X-Dz-User, which Claude Code can send through ANTHROPIC_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.

The Teams page in the Nautili dashboard, listing each team with its Claude Code spend so teams can be compared side by side.

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.

The Limits step of the guardrail wizard in the Nautili dashboard, where the dollar budget for a group is set before the guardrail is reviewed and saved.

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

View all articles

Stay in the loop.

Product updates, technical guides and infrastructure thinking from Nautili.

No spam. Unsubscribe anytime.