Claude Code Token Cost: What a Team Really Spends

Claude Code token cost is the question every engineering lead asks after the first month: how much is this costing per developer, and why does it vary so much? The honest answer is that it depends on how you work more than on how much you work. Long sessions, agent teams and parallel agents all multiply tokens in ways that aren't obvious from the outside. This guide covers Anthropic's published averages, how to see your own usage, how billing differs by plan, where tokens actually go, and the costs that only appear when a team runs many agents at once.

Is Claude Code expensive?

According to Anthropic's cost documentation, across enterprise deployments the average is around $13 per developer per active day and $150 to $250 per developer per month, with 90% of users staying below $30 per active day. Costs vary widely with model choice, codebase size, and habits such as running several instances or automation. Anthropic's advice is to run a small pilot, measure, and budget from your own baseline.

That range is for API-billed usage. On subscription plans, usage is included up to the plan's limits, so the question becomes how fast you reach them rather than what you pay per token.

How to check your Claude Code token usage

• /usage shows the current session's token usage and an estimated cost at list price, broken down by model. Subscribers also see plan usage bars and a breakdown of what's consuming their allowance: skills, subagents, plugins and MCP servers by share, plus flags for behaviours like long context or cache misses.
• The prompt cache line in /usage shows how much of your input came from cache. A low share means you're paying full price to re-process the same context.
• /insights analyses your recent sessions and writes a report on how you work and where sessions went wrong.
• The spinner shows a live count of output tokens for the current turn.

These figures are estimates computed locally; your Console usage page or your organisation's spend report is the authoritative bill.

How billing works by plan

Setup	How usage is counted	Where to see and cap it
Pro or Max	Included up to the plan's limits; optional usage credits beyond them	/usage; spend limit for usage credits
Team or Enterprise	Per-seat allowance on a rolling five-hour window and a weekly window, shared with Claude chat and Cowork	Spend report in org analytics; spend limits in admin settings
Claude Console (API)	Per token, billed to the organisation	Console usage page; workspace spend limits
Bedrock, Agent Platform, Foundry	Per token, billed by your cloud	Your cloud's billing; OpenTelemetry for per-user numbers

On Team and Enterprise plans, hitting "session limit" or "weekly limit" means the seat allowance window, which is shared across models, so switching model doesn't restore access. Usage credits, if your admin turns them on, let developers continue past it up to a spend limit. We run on the monthly plans ourselves; the API works too. Which is cheaper depends on how intensively you work and which models you use.

Where the tokens actually go

Claude Code sends your whole conversation with every request, and every tool call adds another request carrying its results. Prompt caching makes re-reading that history cheaper, but it's still read. That's why usage climbs in long sessions even when you aren't doing much. Anthropic lists the usual causes:

• Long context. An all-day session makes a one-line question expensive.
• Cache misses. The first message after a break longer than the cache lifetime reprocesses everything. The lifetime is an hour on a subscription and five minutes by default on an API key.
• Scheduled tasks and goal check-ins that fire while the session is idle.
• Subagents and workflows, each sending their own requests.
• Agent teammates, each a full session that keeps consuming until it exits.
• Compaction, which reads the conversation it summarises.

The costs of parallel agents

Running several agents multiplies tokens in two ways. The obvious one is volume: each agent is a separate context. Anthropic's documentation says agent teams use roughly seven times more tokens than standard sessions when teammates run in plan mode, because each teammate keeps its own context window.

The less obvious one is waste. When parallel agents don't know about each other, they pay for the same work twice:

• Duplicate exploration. Each agent reads the same files to understand the same module.
• Conflicting work. Two agents build incompatible changes to the same file. One is thrown away, or both are reworked after a merge conflict.
• Fixing collisions. Tokens spent diagnosing breakage that happened because nobody saw two changes meet.

My co-founder Nick and I run between 2 and 15 agents at a time on one repository. Before we coordinated them, the conflicting-work line was the expensive one. Two features that both touched the same schema meant one agent's afternoon of tokens became rework. Since we started having every agent declare its files before editing, collisions are refused at the start, when they cost a one-line message instead of a rebuild. Between August 3 and October 18, 2026, that happened 40 times.

How to reduce Claude Code token usage

From Anthropic's guidance, roughly in order of impact:

1. Clear between unrelated tasks with /clear. Stale context is paid for on every message. Rename the session first if you want to come back.
2. Match the model to the job. Sonnet handles most coding work at lower cost than Opus; use smaller models for simple subagents with model: haiku.
3. Keep CLAUDE.md short and move occasional workflows into skills, which load only when used. See CLAUDE.md best practices for teams.
4. Turn off MCP servers you aren't using, and prefer CLI tools like gh where they exist.
5. Lower the effort level with /effort for simple tasks.
6. Filter noisy output with hooks. A PreToolUse hook can rewrite a test command to show only failures, so Claude reads hundreds of tokens instead of thousands. See Claude Code hooks.
7. Delegate verbose work to subagents so logs and searches stay out of the main context.
8. Plan before you build on anything non-trivial, to avoid paying for the wrong implementation. See Claude Code plan mode.
9. Keep agent teams small and shut teammates down when they're done.

Managing cost for a team

• Start with a pilot, establish cost per developer, then roll out.
• Use the reporting your plan offers: the org spend report and analytics on Team and Enterprise, workspace limits and the Claude Code Analytics API on the Console, OpenTelemetry on cloud providers.
• Set caps where you can: usage-credit spend limits by organisation, group or member; workspace limits for API usage.
• Report at your real rates with the managed modelPricing setting, so /usage matches your contract.
• Know the background cost. Anthropic puts background work like conversation summarisation at typically under $0.04 per session. If idle sessions cost far more, look for scheduled tasks, loops or teammates left running.
• Watch for parallel waste, not just volume. More agents should mean more finished work, not more rework. We look at why it often doesn't in the AI productivity paradox.

Rate limits for API organisations

If your team uses Claude Code through the Claude Console, Anthropic suggests per-user rate limits that shrink as the team grows, because fewer people use it at the same moment in larger organisations:

Team size	Tokens per minute per user	Requests per minute per user
1-5 users	200k-300k	5-7
5-20 users	100k-150k	2.5-3.5
20-50 users	50k-75k	1.25-1.75
50-100 users	25k-35k	0.62-0.87
100-500 users	15k-20k	0.37-0.47
500+ users	10k-15k	0.25-0.35

These limits apply at the organisation level, so one developer can briefly use more than their share when others are idle. Plan for higher limits around events like live training sessions, when everyone runs Claude Code at once. A team running several parallel agents per developer also behaves more like a larger team than its headcount suggests, so size limits by active agents, not just people.

Spend tokens on work, not on collisions

Claude Code costs about what Anthropic says on average, and far more when sessions run long, teams grow large or agents duplicate each other's work. Measure with /usage, clear context often, pick models deliberately and keep instructions lean. On a team, the biggest saving is often the work you don't redo. SyncStaff prevents the collisions that cause it: every agent, from any tool, declares its change and leases the files first, so parallel agents spend their tokens on separate work.

Sources: Manage Claude Code costs, Claude Code agent teams documentation.