What Claude Code costs per developer, by Anthropic's own figures

Claude Code is Anthropic's coding tool. A developer types a request in a terminal, the text window where commands are typed, and an AI model reads files, runs commands and edits code. All of that work is counted in tokens: pieces of text the model reads or writes. Anthropic's pricing page, read on 4 October 2026, estimates one token at 4 characters or 0.75 of an English word [3]. The cost of a developer using Claude Code is the cost of the tokens their sessions use.

This page is for the person who approves that spend. It gives Anthropic's own figures for a developer's cost, explains why the figure moves, and sets out how to run a pilot that produces a number for your own team. It is the first page of the guide to Claude Code costs for teams.

Anthropic's three figures, and what they are

Anthropic's documentation on managing costs, read on 4 October 2026, gives three figures. All three are Anthropic's own statements about its own product, stated for what Anthropic calls enterprise deployments [1]:

• Anthropic states an average of $13 per developer per active day.
• Anthropic puts the monthly figure at $150 to $250 per developer.
• Anthropic states that costs stay below $30 per active day for 90 percent of users.

Three things about these figures matter to a budget. First, they are averages across other companies' deployments, so they describe those deployments. Your team will produce its own figure. Second, the daily figure is per active day. The page leaves two things open: the meaning of "active day", and the number of active days a month behind the $150 to $250 figure. Third, the same page says per-developer costs "vary widely" with model choice, codebase size and usage patterns such as running several instances at once or automation [1]. Anthropic's advice follows from that: start with a small pilot group and use the tracking tools to establish a baseline before a wider rollout [1].

Anthropic charges for Claude Code by token consumption through its API, the interface that programs such as Claude Code use to send requests to the model [1]. On a Claude for Teams or Enterprise plan, each member has a seat: a paid place on the plan. Each seat comes with an allowance, an amount of usage included in the seat's price, which resets on a rolling five-hour window and a weekly window [1]. Anthropic's documentation says usage inside that allowance "isn't metered in dollars" [1]. So the $13 figure describes token cost as Anthropic measures it, and a seat-based team sees dollar figures only for usage credits, which is paid usage a member draws on after the allowance runs out. The page on subscription seats or pay per token explains the three ways a company pays.

Why one developer costs more than another

The figure moves with what the developer does and how the tool is set up. Each row below comes from Anthropic's documentation, read on 4 October 2026. Two terms in the table: an API key is the secret string a program uses to sign in to an API account, and a cloud provider means Amazon Bedrock, Google Cloud's Agent Platform or Microsoft Foundry, the Amazon, Google and Microsoft services that offer Claude models inside a company's existing cloud account.

What moves the cost	Direction	What Anthropic's documentation says
Model choice	Up with Opus, down with Sonnet	Sonnet "handles most coding tasks well and costs less than Opus"; Opus is for complex architectural decisions or multi-step reasoning [1]. On Anthropic's pricing page, Claude Opus 5.5 is listed at $4 per million input tokens and $20 per million output tokens, and Claude Sonnet 5.5 at $2 and $10 [3]
Long sessions	Up	Claude Code sends the full conversation with every request, so a one-line question in a session open all day "still draws usage for the whole conversation" [1]
Breaks longer than the cache lifetime	Up	The first message after such a break reprocesses the full context. The lifetime is an hour on a subscription, five minutes once the member is drawing on usage credits, and five minutes by default on an API key or cloud provider [1]
Extended thinking	Up	The model's reasoning before it answers is billed as output tokens, and the default budget "can be tens of thousands of tokens per request depending on the model" [1]
Several instances or automation	Up	Named by Anthropic as a usage pattern that widens the range of per-developer cost [1]
Agent teams	Up	Several Claude Code instances, each with its own context; Anthropic puts the usage at 7 times a standard session when teammates run in plan mode. Off by default [1]
Subagents and scheduled tasks	Up	Every subagent sends its own requests; a scheduled task fires on its interval even while the session is idle, sending the full context each time [1]
Codebase size	Up	Named by Anthropic as one of the three main sources of variation, with model selection and usage patterns [1]
Newer tokenizer	Up	Claude 4.7 and later models use a newer tokenizer, which Anthropic puts at 30 percent more tokens for the same text [3]
Prompt caching	Down	Repeated content such as the system prompt is read from a cache at a lower price; Claude Code does this automatically [1]
Clearing between tasks and the default model	Down	Anthropic names "long sessions that were never cleared" and "Opus left as the default model" as the usual causes of unexpectedly high spend on API and cloud-provider plans [1]
Background work	Small	Summarising conversations and some commands use tokens while idle, which Anthropic puts at typically under $0.04 per session [1]

Some terms in that table need plain words. The context is everything the model reads in one request: Anthropic's instructions, the project's notes, the whole conversation so far, and every file the model has opened. Prompt caching is a store of request text that the model service has already processed; when the start of the next request is identical, that part is read from the store at a lower price. A subagent is a second copy of Claude that does one task in its own separate context and returns a summary. An agent team is a group of such copies working together on one job. Plan mode is a mode in which Claude explores the code and proposes an approach before it edits anything. A scheduled task is work Claude Code runs again on a timer. The system prompt is the set of instructions Anthropic writes for the model, sent at the start of every request.

The pattern across the table is that cost follows the amount of text the model reads on each request, and the developer controls most of that text. The sister guide on how to reduce Claude Code token usage covers each habit, and its page on why usage rises in a long session covers the long-session rows in detail.

A coding seat uses more than a chat seat

A finance lead who already budgets for Claude chat seats will ask whether a Claude Code seat costs the same. Anthropic's documentation answers directly: "Budget more for a coding seat than a chat seat" [1]. The reason it gives is what each turn contains. A Claude Code turn contains file contents, tool calls (actions such as reading a file or running a command) and multi-step reasoning, so "one debugging session can consume more than a day of chat" [1].

Anthropic names a planning document for administrators, the Claude Enterprise consumption guide. By Anthropic's description, it explains how consumption differs across Claude chat, Claude Code and Cowork (a third Anthropic product on the same plan), and gives per-user dollar starting points for budgeting [1]. That guide was outside the set of documents read for this page, so no figure from it appears here. If your company is on an Enterprise plan, read it alongside this page.

On Teams and Enterprise plans the allowance is shared between Claude Code, Claude chat and Cowork, and its size depends on the seat tier, Standard or Premium [1]. A developer who uses all three draws on one allowance. That is the first reason a coding seat needs a higher tier, or usage credits, sooner than a chat-only seat does.

How to run a pilot and read a baseline

Anthropic's advice is to pilot first [1]. The steps below use the tracking tools the documentation names. The group sizes and durations are Reveneau's recommendation, because the documentation gives none.

1. Pick a pilot group. Choose developers who work on the codebases the wider team will work on, because codebase size is one of Anthropic's three sources of variation [1]. Reveneau recommends a group small enough that one person can ask each member what they did, and a pilot long enough to include at least one full weekly allowance window on a subscription plan.
2. Decide which setup the pilot runs on, because the screens that show spend differ. On a Teams or Enterprise plan, the spend report in organisation analytics shows estimated spend per user and per model, updated daily, and appears once usage credits are turned on [1]. On the Claude Console, which is Anthropic's web console for API accounts, the dashboard (a web page of figures and charts) at platform.claude.com/claude-code shows daily API costs in dollars alongside user count, and a team insights table with each member's spend this month [2]. On a cloud provider (Amazon Bedrock, Google Cloud's Agent Platform or Microsoft Foundry), spend appears in your cloud billing console, and Anthropic's dashboards do not cover it [1]. The page on where to see Claude Code spend lists every screen.
3. Count active days as well as dollars. The analytics dashboard for Teams and Enterprise shows daily active users and sessions, and the Console dashboard shows the same on its Activity chart [2]. Divide each developer's spend by their active days to get a figure in the same unit as Anthropic's $13.
4. Read the model mix. The spend report breaks spend down per model [1]. If one developer's cost is high, the first two things to check are the model and the session length, because those are the two causes Anthropic names for unexpectedly high spend [1].
5. Treat every dashboard figure as an estimate. Anthropic's documentation says the Console dashboard's spend figures "are estimates for analytics purposes" and that actual costs are on the billing page [2], and the spend report shows "estimated spend" [1]. Reconcile the pilot against the invoice before you multiply anything out.

The result is a baseline: your own cost per developer per active day, on your own code, with your own model defaults. Compare it with Anthropic's $13 and $30 figures as a reference only. If your figure is above $30, the model default and the session habits in the table above are the places to look first.

A worked example makes the arithmetic plain. It is an invented example, using Anthropic's figures only. If a pilot of 8 developers spends $1,040 in a month and the eight developers have 80 active days between them, the cost per active day is $1,040 divided by 80, which is $13, the same as Anthropic's stated average. If the same group had 40 active days, the cost per active day would be $26, still under Anthropic's $30 figure for 90 percent of users, with half the use.

What to do with the number

Reveneau recommends budgeting from the pilot baseline, with Anthropic's $150 to $250 monthly figure as a reference point for the first month, before the pilot reports. Set the spend controls before the wider rollout, because every setup has one: the page on spend limits for an organisation, a group and a person explains each control, and the page on per-developer usage reporting explains how to get the per-person numbers the pilot needs.

Reveneau is an AI software development consultancy. All of its code is written by AI, and every change must pass an eval suite, a set of automated tests written from the specification, before release, so token use is a running cost of every Reveneau build. Reveneau is independent of Anthropic, and every figure on this page is Anthropic's own statement about its own product. If you want help setting up a pilot and reading its baseline, contact Reveneau.