Claude Code pricing: plans, API rates and what drives the bill

TL;DR

• Claude Code pricing has two models: a flat subscription (Pro at $20 a month, Max at $100 or $200, Team seats at $25 or $125 billed monthly) with shared usage limits, or per-token billing at API rates through Anthropic, a cloud provider or a gateway.
• The credential Claude Code sends decides the bill. An ANTHROPIC_API_KEY or a gateway credential replaces the subscription login, so those requests are billed per token and subscription limits no longer apply.
• Most tokens in a long session are cache reads. In Anthropic’s own example, cache reads and writes make up about 85% of a $0.55 session, and the same tokens without caching would cost about $3.05.
• Anthropic reports enterprise deployments average about $13 per developer per active day and $150 to $250 per month, with 90% of users under $30 a day.
• Teams on API or cloud billing need their own per-developer limits. The options are Console workspace limits, cloud budgets, OpenTelemetry, Anthropic’s Claude apps gateway, or a general LLM gateway such as the open-source Bifrost.

Claude Code pricing is set by how a developer signs in, not by the tool itself: Anthropic’s coding agent is included in every paid Claude subscription, and it can also run on per-token API billing through the Claude Console, Amazon Bedrock, Google Cloud’s Agent Platform, Microsoft Foundry or an LLM gateway. On a subscription the cost is a fixed monthly fee with usage limits; on API billing the cost is whatever the tokens add up to. This guide sets out every plan price, the API rates per model, what actually drives Claude Code cost in a session, and the controls a team can use to cap it, all taken from Anthropic’s pricing pages and documentation as published in October 2026.

How Claude Code is billed

Claude Code is billed according to the credential it sends with each request. A claude.ai login draws on a subscription’s usage allowance; a Console API key, a cloud credential or a gateway credential is billed per token at API or contracted rates. Anthropic’s cost guide opens with the simpler version: “Claude Code charges by API token consumption.”

The Claude Code cost documentation lists three organizational setups, and each has its own billing surface. On Claude for Teams and Enterprise, usage draws from each member’s seat allowance. On the Claude Console and on cloud providers, usage is billed per token to the organization. If an organization mixes sign-in methods, each developer is metered according to the method they authenticated with.

Figure 1: The credential Claude Code sends, not the plan a developer owns, decides which bill a request lands on.

Figure 1 matters because the credentials override each other silently. Anthropic’s help center warns that if an ANTHROPIC_API_KEY environment variable is set, Claude Code uses it instead of the Pro, Max, Team or Enterprise subscription, “resulting in API usage charges rather than using your subscription’s included usage.” The gateway documentation makes the same point for gateways: while a gateway credential or apiKeyHelper is active, the subscription’s usage limits do not apply and the traffic is billed per token to whoever owns the provider key behind the gateway. Setting only ANTHROPIC_BASE_URL, without a gateway credential, keeps the subscription as the active login.

Claude Code pricing plans compared

Claude Code is included in Pro, Max, Team and Enterprise, and is not available on the Free plan. Individual plans cost $20 (Pro, billed monthly) and $100 or $200 (Max). Team seats cost $25 or $125 billed monthly. Enterprise charges $20 per seat plus all usage at API rates.

The table collects the prices from Anthropic’s pricing page and the Max plan help article. Prices exclude tax and, in Anthropic’s words, are “subject to change at Anthropic’s discretion.”

Two details in the fine print change the arithmetic. Max includes $100 to $200 a month in API credits and Team includes up to $500 a month in pooled API credits, but the Pro and Max help article and the Team and Enterprise help article both state that those monthly API credits cannot be used in Claude Code. And Max is sold monthly only, so the annual discount that applies to Pro and Team does not apply to it.

Older Enterprise contracts work differently. The Team and Enterprise help article explains that Claude Code is included with the single Enterprise seat on new and self-serve plans, while older Enterprise plans required a “Chat + Claude Code” or Premium seat to use it.

Claude Code usage limits and usage credits

Every paid plan meters Claude Code against a rolling five-hour session window and a weekly limit, shared with Claude on web, desktop and mobile. When a limit is reached, developers can wait for the reset, upgrade, or turn on usage credits, which bill further usage at standard API rates up to a monthly spend limit.

Anthropic does not publish limits as token or message counts. Its pricing page says how much a user can do “depends on the length and complexity of your conversations, the model you choose, and the features you use, so there’s no fixed message count,” and reserves the right to apply other weekly, monthly, model or feature caps. That is why no honest comparison can convert a Max plan into an exact number of API dollars.

The limits interact with Claude Code in specific ways documented across Anthropic’s help center and cost guide:

• Shared pool. Terminal and IDE use of Claude Code draws on the same allowance as Claude chat, so a heavy chat day leaves less for coding.
• Model-specific limits. Max plans carry a separate weekly limit for Fable. A developer who hits a model-specific limit can keep working by switching models with /model; a session or weekly limit applies across all models.
• Usage credits. On Pro and Max, usage credits are enabled under Settings, Usage, with a monthly spend cap, prepaid funds and optional auto-reload, according to the usage credits help article. On Team and seat-based Enterprise plans, admins turn them on and set limits at the organization, group or member level.
• Cache lifetime. The cost guide notes that the prompt cache lifetime is one hour on a subscription but drops to five minutes once a developer is drawing on usage credits, so idle breaks get more expensive at exactly the point the developer starts paying per token.

A longer treatment of how engineering teams plan around these windows is in an analysis of Claude Code usage limits and how teams manage them.

Claude Code API pricing by model

On API billing, Claude Code costs the model’s per-token rate for every input, output, cache-write and cache-read token it uses. Sonnet 5.5 costs $2 per million input tokens and $10 per million output tokens; Opus 5.5 costs $4 and $20; Haiku 5.5 starts at $0.10 and $0.50.

The figures below come from the Claude API pricing page. Usage credits on a subscription and the usage portion of an Enterprise plan are billed at these same standard rates.

Four modifiers apply on top of the base rates:

• Cache multipliers differ by model. Cache reads cost 0.05x the input price on Opus 5.5 and Sonnet 5.5, 0.025x on Fable 5.1, and 0.1x on other models. A five-minute cache write costs 1.25x input and a one-hour write 2x.
• Tokenizer. Anthropic states that Claude 4.7 and later models use a newer tokenizer that produces “approximately 30% more tokens for the same text,” so per-token prices are not directly comparable with older models.
• Fast mode and data residency. Fast mode for Opus 5.5 runs up to 2.5x faster at 2x standard pricing, and US-only inference adds a 1.1x multiplier.
• Cloud platforms. Claude on Amazon Bedrock and Google Cloud is invoiced by the cloud provider, and regional or multi-region endpoints carry a 10% premium over global endpoints for Claude 4.5 models and later.

Thinking tokens add to every one of these. Claude Code’s cost guide says extended thinking is on by default, that thinking tokens are billed as output tokens, and that thinking cannot be turned off on Opus 5.5, Sonnet 5.5, Haiku 5.5 or the Fable models. The wider economics of paying for reasoning are covered in The Frontier Wire’s piece on why the reasoning-model era has a cost problem, and the current model line-up in its ranking of AI models.

What drives Claude Code cost

Claude Code cost is driven mainly by context size, because the agent resends the system prompt, tools and entire conversation history with every request. Prompt caching bills most of that at a fraction of the input price, so the cache hit rate, model choice, thinking effort and the number of subagents decide the total.

Anthropic’s cost guide puts it directly: “Token costs scale with context size.” Each time Claude uses a tool, Claude Code sends another request that carries the tool results, so a single user turn can produce several model calls. Figure 2 shows how one of those requests is priced.

Figure 2: In a long session most tokens are cache reads, so the cache hit rate moves the bill more than prompt length does.

A worked example

The /usage command in Anthropic’s documentation shows a sample session on Claude Sonnet 4.6: 1,200 input tokens, 5,300 output tokens, 940,000 cache-read tokens and 50,000 cache-write tokens, for a total of $0.55. Applying the list prices above reproduces that figure and shows where the money went.

Cache reads and writes account for about 85% of the cost, and fresh input almost nothing. Had the same 991,200 prompt tokens been billed at the full $3 input rate with no caching, the session would have cost about $3.05, more than five times as much. Holding the token counts fixed, the same session would cost about $0.27 on Sonnet 5.5 and about $0.55 on Opus 5.5, although the newer tokenizer would produce more tokens for the same text.

The behaviours that raise spend

The cost guide’s section on why usage climbs in a long session lists the specific behaviours that inflate a bill:

• Long context. A one-line question in a session open all day still pays to re-read the whole conversation.
• Cache misses. The first message after a break longer than the cache lifetime reprocesses the full context. On an API key or cloud provider the default lifetime is five minutes.
• Subagents and agent teams. Each subagent sends its own requests. Agent teams use “approximately 7x more tokens than standard sessions when teammates run in plan mode.”
• Scheduled tasks and idle check-ins. Loops and goal check-ins send the full context each time they fire, even while the developer is away.
• Compaction. /compact reads the conversation it summarizes, so compacting a large context is itself a large request; /clear costs nothing.
• Background traffic. Conversation summarization and status checks typically cost under $0.04 per session.

MCP servers used to be a large hidden cost because tool definitions sat in every request. Claude Code now defers MCP tool definitions by default so only tool names enter context, but each server still adds instructions and every tool result is resent with the history. An analysis of reducing MCP token costs for Claude Code at scale measures how much a gateway that filters tools can save.

Claude Code cost per developer

Anthropic reports that across enterprise deployments Claude Code averages about $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. Those figures describe per-token billing; subscription users pay a flat fee instead.

Set against the plan prices, the averages explain why the choice of billing model matters. The midpoint of Anthropic’s monthly range sits above a Max 5x subscription and near Max 20x, while a Premium Team seat costs $125 a month billed monthly. A developer whose usage is close to the average would usually pay less on a subscription, provided the plan’s limits fit their working pattern; a developer with occasional heavy days might pay less on API billing, because quiet days cost nothing.

The comparison has limits. Anthropic does not express plan allowances in tokens, so the exact break-even point between Max and API billing cannot be calculated from public information. Per-developer cost also varies widely with “model selection, codebase size, and usage patterns such as running multiple instances or automation,” in the cost guide’s words, which is why Anthropic recommends a small pilot to establish a baseline before a wider rollout. A breakdown of the hidden cost of Claude Code at enterprise scale walks through how those variables compound across hundreds of seats.

For Console customers Anthropic also publishes rate-limit guidance that doubles as a capacity plan. It recommends 200,000 to 300,000 tokens per minute per user for teams of one to five, falling to 10,000 to 15,000 per user above 500 users, because fewer developers work concurrently in larger organizations.

Tracking Claude Code usage and cost

Claude Code reports cost in three places: the /usage command in each session, Anthropic’s analytics dashboards and APIs, and OpenTelemetry metrics exported to an organization’s own stack. Only the OpenTelemetry export works on every billing setup and streams per-user cost in near real time.

In the terminal. The commands reference lists /usage, with /cost and /stats as aliases. It shows session cost, plan usage limits and activity, and on subscription plans a breakdown attributing recent usage to skills, subagents, plugins and individual MCP servers. The cost guide notes that the dollar figure is computed locally at list price and is an estimate; authoritative billing lives in the Claude Console. Since version 2.1.242, administrators can set a modelPricing managed setting so the figure reflects contracted rates.

In Anthropic’s dashboards. Where an organization sees spend depends on its setup:

In an observability stack. The OpenTelemetry guide enables export with CLAUDE_CODE_ENABLE_TELEMETRY=1 and an exporter such as OTEL_METRICS_EXPORTER=otlp. Claude Code then emits claude_code.cost.usage in US dollars and claude_code.token.usage, which can be broken down by token type, user, team, model, skill, plugin or agent. Administrators can lock the exporter settings through managed settings so developers cannot turn them off. The analytics guide covers the adoption dashboards that sit alongside these metrics. A comparison of approaches to monitoring Claude Code token usage through a gateway covers the case where telemetry needs to be collected centrally rather than from each laptop.

Controlling Claude Code spend across a team

Teams cap Claude Code spend at whichever layer owns the bill: seat allowances and usage-credit limits on Team and Enterprise plans, workspace limits in the Claude Console, budgets in the cloud console, or per-developer budgets in a gateway that every request passes through.

Each option covers a different slice of the problem. Plan-level controls only govern subscription traffic. Console workspace limits cap the total Claude Code spend for the workspace, and Anthropic suggests a workspace rate limit to stop Claude Code traffic crowding out production workloads on the same organization. Cloud budgets alert on an account rather than a developer, and Anthropic’s own analytics do not see cloud usage at all.

For per-developer limits on API or cloud billing, Anthropic’s cost guide names three routes:

• OpenTelemetry, for attribution without enforcement.
• Anthropic’s Claude apps gateway, a self-hosted gateway shipped with Claude Code. Its spend limits set daily, weekly or monthly caps per user, identity-provider group or organization, and return a 429 billing error until the period resets on a UTC boundary.
• A general LLM gateway that tracks spend per key. The guide notes that several large enterprises reported using LiteLLM, whose virtual keys track spend per key, user and team and accept a maximum budget.

The difference between the last two is scope. The Claude apps gateway serves Claude clients only, while a general gateway can apply one set of budgets to Claude Code, other coding agents and application traffic. Anthropic’s gateway documentation also notes that it does not support routing Claude Code to non-Claude models through any gateway. The Frontier Wire’s ranking of gateways for Claude Code, Codex CLI and Cursor compares five of them on those criteria, and its guide to LLM cost management at the gateway covers budget hierarchies and reset periods in general. A practitioner’s guide to governing Claude Code usage across engineering teams applies the same controls to a rollout plan.

Per-developer budgets with Bifrost

Bifrost, an open-source AI gateway, is a documented example of gateway-level Claude Code cost control: each developer gets a virtual key with its own budget and rate limits, budgets roll up to teams and customers, and every request is priced and logged. It is used here because its documentation covers each step of the Claude Code setup.

Bifrost is written in Go, published under Apache 2.0 by Maxim AI, and puts 25+ providers and 10,000+ models behind one OpenAI-compatible API, with an Anthropic-compatible path for Claude Code. Its source is in the Bifrost repository. The project’s published benchmark reports 11 µs of added overhead per request at 5,000 RPS on an AWS t3.xlarge, which is negligible against a coding-agent turn measured in seconds.

Connecting Claude Code. The Claude Code integration guide points ANTHROPIC_BASE_URL at the gateway’s /anthropic path and puts a virtual key in ANTHROPIC_AUTH_TOKEN, so the developer needs no Anthropic login and every request is billed per token to the organization’s provider keys. A second mode keeps subscription billing: the developer signs in with /login and sends the virtual key in an x-bf-vk custom header, so Bifrost forwards the subscription token to Anthropic and still applies governance and logging, while subscription limits continue to apply. For larger rollouts, an apiKeyHelper command supplies short-lived credentials so each request is attributed to the signed-in user.

Budgets and limits. Virtual keys carry allowed providers and models, a budget and request and token rate limits. The budget and limits documentation describes a hierarchy of customer, team, virtual key and per-provider budgets. Every applicable budget must have room for a request to proceed, and the request’s cost is deducted from each level. Budgets reset on periods from a minute to a year, including quarterly, and can be aligned to calendar boundaries in UTC.

Figure 3: Every budget in the hierarchy must have room, and the request’s cost is charged to each level it passed.

Pricing each request. Bifrost’s model catalog syncs a pricing sheet every 24 hours when a config store is attached and prices cache-read and cache-write tokens separately, along with tiered rates for long-context requests. The built-in logs record tokens, cost and latency for each request, and the Prometheus exporter publishes a bifrost_cost_total counter for dashboards and alerts.

Keeping the cache warm. Claude Code sends an x-claude-code-session-id header on every request, and Bifrost’s session affinity uses it with no configuration to keep a session on the provider and key that served it. That matters for cost, because provider prompt caches are usually scoped to a key, and a session spread across keys pays to rebuild its cache.

The Claude Code gateway guide and an integration walkthrough for Claude Code and Bifrost show complete configurations, and the Claude Code resource page summarizes the setup modes.

Enterprise tier. SSO sign-in through user provisioning, access profiles that stamp the same budget template onto every user or team, audit logs and high-availability clustering are part of Bifrost Enterprise.

Reducing Claude Code token usage

The largest reductions come from keeping context small and matching the model to the task: clear between unrelated tasks, default to Sonnet and reserve Opus for hard problems, lower thinking effort for routine work, and push verbose output into hooks and subagents. These habits cut cost on subscription and API billing alike.

Anthropic’s cost guide recommends the following, in roughly descending order of impact:

1. Clear between tasks. /clear starts a fresh session, so stale context stops being resent. Use /rename first to find the session again with /resume.
2. Choose the model deliberately. Sonnet handles most coding tasks and costs half as much as Opus per token; subagents doing simple work can be pinned to haiku.
3. Lower thinking effort. /effort reduces the reasoning budget on routine tasks, which matters because thinking is billed as output.
4. Keep CLAUDE.md short. It loads into every session; Anthropic suggests under 200 lines, with specialized instructions moved into skills that load on demand.
5. Filter tool output with hooks. A PreToolUse hook that returns only test failures can shrink tens of thousands of tokens of log output to hundreds.
6. Prefer CLI tools over MCP servers where both exist, and disable unused servers with /mcp.
7. Use plan mode for complex work and press Escape early when a run heads the wrong way, so rework does not burn tokens.
8. Keep agent teams small and shut teammates down when their task is finished.

At the organization level, the same principles apply through policy rather than habit: a default model set in managed settings, budgets that stop runaway automation, and dashboards that show which teams and workflows consume the most. Further detail on each technique is in a guide on how to reduce Claude Code token costs and a broader look at LLM cost optimization with caching and routing.

Choosing a plan or billing model

Individuals should start on Pro and move to Max when limits interrupt real work. Teams under 150 people usually fit a Team plan with Premium seats for heavy users. Organizations that need per-developer budgets, cloud billing or several coding agents usually move to API billing with a gateway in front.

Whichever route a team takes, the same check applies before rollout: confirm which credential each developer’s machine actually sends. A stray ANTHROPIC_API_KEY in a shell profile turns a flat subscription into per-token billing without any warning on the invoice until it arrives. The Frontier Wire’s explainer on what an AI gateway does and what it costs to run one covers the operating side of the gateway route, and its gateway comparison for coding agents covers which products support Claude Code fully.

Limits of this guide

This guide was compiled from Anthropic’s pricing page, API pricing documentation, Claude Code documentation and help-center articles, and from each gateway’s own documentation, all read in October 2026. No Claude Code sessions were run or billed for it, and the worked example uses Anthropic’s published sample rather than a measured workload.

Claude Code pricing changes often. During 2026 Anthropic introduced new model families with different cache multipliers, renamed extra usage to usage credits, and made Sonnet 5’s introductory price permanent. Plan allowances are not published in tokens and can be adjusted at Anthropic’s discretion, so the comparison between subscriptions and API billing will always carry some uncertainty. Teams setting budgets should treat Anthropic’s per-developer averages as a starting point, measure their own baseline in a pilot, and revisit plan choices each quarter. For most teams, Claude Code pricing comes down to two decisions made once: which credential every machine sends, and where the per-developer limit is enforced.