Claude Code Costs: Track, Cap, and Reduce Token Spend

Anthropic publishes one set of averages, from enterprise deployments: 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. Those are averages across many organisations; per-developer cost varies widely with the model, codebase size, and habits such as running several sessions in parallel or automation.

The docs' advice for budgeting is to run a small pilot group first, measure a baseline with the tracking tools below, and only then extrapolate. A team that runs Claude Code in CI, uses agent teams, or leaves Opus as the default will sit well above the averages.

How you pay depends on how you sign in. On Pro and Max plans, usage is included in the subscription up to its limits; on Teams and Enterprise, each seat has an allowance shared with Claude chat and Cowork; on a Claude Console account or a cloud provider, every token is billed to the organisation.

The /usage command is the starting point. Its Session block shows token use for the current session by model, including cache reads and writes, and a cost estimate:

1Total cost:            $0.552Total duration (API):  6m 20s3Total duration (wall): 6h 33m 10s4Usage by model:5   claude-sonnet-4-6:  1.2k input, 5.3k output, 940.0k cache read, 50.0k cache write ($0.55)

Two things about that figure: it is computed locally at list price (unless your organisation set a modelPricing table in managed settings), so it is an estimate, not an invoice; and it resets at /clear. On Pro and Max plans, the session cost is not what you pay; subscribers should read the plan usage bars on the same screen.

Below it, a Prompt cache line shows how much of your input was served from cache, how many misses there were, and whether the cache is still warm. On paid plans, /usage also attributes recent usage to skills, subagents, plugins, and MCP servers, and flags behaviours such as long context or cache misses when they account for 10% or more. Press d or w to switch between 24 hours and 7 days.

For patterns rather than numbers, /insights analyses your recent sessions and writes an HTML report on what you work on, where friction happened, and how to work more effectively.

On Teams and Enterprise, each member's usage draws from a seat allowance that resets on a rolling five-hour window and a weekly window. That allowance is the default ceiling. To let members go past it, turn on usage credits and set spend limits at the organisation, group, or member level in the claude.ai admin console.

On the Claude Console, the first Claude Code login creates a workspace named "Claude Code" for centralised tracking. Set a workspace spend limit on it, and a workspace rate limit so Claude Code cannot crowd out your production API traffic.

On cloud providers, spend lives in your cloud account and Anthropic's analytics do not see it. For per-user attribution, export OpenTelemetry from each machine, use a Claude apps gateway (which adds per-user spend caps), or route through an LLM gateway that tracks spend per key.

If your organisation pays contracted rates, set modelPricing in managed settings so /usage, the status line, and OpenTelemetry report your rates instead of list price. It changes the reported figures, not what is charged.

For API organisations sizing their limits, Anthropic recommends the tokens-per-minute (TPM) and requests-per-minute (RPM) figures above. For example, 200 users at 20k TPM each is 4 million TPM in total.

The per-user figure falls as the team grows because fewer people use Claude Code at the same moment in a larger organisation. The limits apply at the organisation level, not per person, so one developer can use more than their share while others are idle. Plan for exceptions: a live training session where everyone starts at once needs a higher allocation than the table suggests.

The docs list the reasons a session that has been open for hours uses more than your activity suggests:

• Long context. Claude Code sends the full conversation with every request, and each tool use adds another request carrying the results. Prompt caching makes the re-reads cheaper, but a one-line question in an all-day session still pays for the whole history.
• Cache misses. After a break longer than the cache lifetime (an hour on a subscription, five minutes by default on an API key or cloud provider, and five minutes once you draw on usage credits), the next message reprocesses the full context.
• Scheduled tasks and check-ins. /loop tasks, cross-session messages, and goal check-ins can start turns while the session is idle, each sending the full context.
• More agents. Every subagent, workflow agent, and agent teammate sends its own requests on top of the main conversation. Agent teams in plan mode use roughly seven times the tokens of a standard session.
• Compaction. /compact reads the conversation it summarises, so compacting a huge context is itself a large request. /clear costs nothing.

The most common causes of unexpectedly high spend on API plans, according to the docs, are long sessions that were never cleared and Opus left as the default model.

The changes with the most effect, in rough order:

1. Clear between tasks with /clear, and use /compact Focus on the API changes when you need continuity but less history. Add compaction instructions to CLAUDE.md if certain details must survive. 2. Match the model to the job. Sonnet handles most coding; reserve Opus for hard architecture and multi-step reasoning. Give simple subagents model: haiku. 3. Lower effort for simple tasks with /effort, since thinking tokens are billed as output. 4. Keep standing context small. Keep CLAUDE.md under about 200 lines and move workflow-specific instructions into skills, which load only when used. Disable MCP servers you are not using, and prefer CLI tools such as gh where they exist. 5. Filter noisy output before Claude sees it. A PreToolUse hook can rewrite npm test to show only failures, turning tens of thousands of tokens of output into hundreds. 6. Avoid rework. Plan mode for complex changes, Esc as soon as Claude heads the wrong way, specific prompts instead of "improve this codebase", and a test or expected output so Claude can check itself.

A code intelligence plugin for typed languages also saves reads: one go-to-definition call replaces a grep plus several speculative file reads.

1. Start a session and do a realistic task for 20 minutes. Run /usage and note the total, the cache line, and any flagged behaviours. 2. Run /context and list the three largest items in context. 3. Act on them: move a workflow section of CLAUDE.md into a skill, disable an unused MCP server, or add the test-output filtering hook from Anthropic's cost guide. 4. Run /clear, switch to Sonnet if you were on Opus, and repeat a similar task. Compare /usage. 5. Run /insights and read the friction points it reports.

Pass criterion: you can say which factor drove your first session's usage (context, cache misses, model, or subagents) and show the second session using less for similar work.