What a coding agent costs per developer: 385 developer-days of our own usage
Five months of our own team's coding-agent traffic: 163 requests and $4.30 on a typical developer day, 378 requests and $13.03 on a heavy one, at list prices with routing (corrected November 7). How that compares with Claude's subscription and seat plans, what moved the bill, and what these numbers don't tell you.
Choosing GPUs? Compare GPUs for your traffic · Get your node measured, free
Correction, November 7, 2026. The dollar figures we first published here were CodeRouter's recorded costs, not list prices as we said. Until October 29, CodeRouter's price table had Claude Opus 4.7 at $15 / $75 per million input / output tokens; Anthropic's list price is $5 / $25, so every Opus 4.7 request was recorded at three times list. Claude cache writes also weren't logged before November. We have repriced every request at list prices and estimated the missing cache writes from November traffic (6.6% of the Claude prompt). The typical day barely moves ($4.34 → $4.30). The heavy day falls from $17.01 to $13.03, the five-month total from $8,043 to $5,581, and the heavy month from about $340 to about $260. Without the cache-write estimate the figures are $4.17, $11.52 and $4,574. The cache figures below are corrected too; request counts are unchanged. We're sorry for the error.
Disclosure first: the usage below is from our own team, and the routing it went through is CodeRouter, a product our team built. TokenWatt measures; CodeRouter is ours. We say which is which throughout.
"How much does Claude Code cost?" has two answers. On a subscription it's the plan price, until you hit the usage limits. On API billing it's whatever your developers send, and most teams have no idea what that is. So we looked at what our own developers actually sent, and what it cost.
What we measured. Five months (May to September 2026) of our team's coding-agent traffic, one API key per engineer, 385 developer-days with at least 20 requests. For each day we priced every request at provider list prices: uncached input, cache reads, cache writes and output. Claude cache writes weren't logged before November, so for those months they are estimated (see the correction above).
One developer, one working day
| Typical day (median) | Heavy day (75th percentile) | |
|---|---|---|
| Requests | 163 | 378 |
| Actual cost, routed across models | $4.30 | $13.03 |
Over the whole period it came to $5,581.
At 20 working days a month that is roughly:
| Typical developer | Heavy developer | |
|---|---|---|
| Requests | ~3,300 | ~7,600 |
| Actual cost, routed | ~$86 | ~$260 |
What this number is, and what it isn't. It's what our requests cost with the routing CodeRouter ran at the time. It isn't what the same work would have cost on a single model. A different model takes a different number of steps to finish the same task, so you can't get that figure by repricing these tokens. Comparing models takes the same tasks run on each, which we're doing separately.
Against the plans (prices as of November 2, 2026)
| Plan | Price | What you get |
|---|---|---|
| Claude Pro | $20/month | Claude Code with usage limits |
| Claude Max | $100/month | 5× Pro usage |
| Claude Ultra | $200/month | 10× Pro weekly usage, no 5-hour limit |
| Claude Team | $25 (Standard) or $125 (Premium) per seat/month | Premium has 5× Standard usage |
| Claude Enterprise | $20 per seat/month + all usage at API rates | 20-seat minimum, billed annually |
| API key (pay per token) | provider list prices | no limits, you pay what you send |
Sources: claude.com/pricing and Anthropic's API pricing page. Check them before you decide; plan limits change.
What the numbers say:
- For one developer, compare your own API spend with the plan prices. Ours ranged from about $86 a month (typical) to $260 (heavy) on routed traffic, against $100 for Max and $200 for Ultra. A subscription covers only Claude models and has usage limits; API billing has no limits, and you pay for what you send.
- Teams that pay API rates feel it first. Claude Enterprise is now $20 a seat plus every token at API prices, and Cursor bills Claude and GPT usage at list price. For those teams what each developer sends is the bill, so measure it per developer.
- Which model does each request moves the bill most. List prices differ a lot: Claude Opus 5.5 is $4 / $20 per million input / output tokens, Sonnet 5.5 $2 / $10. Whether a cheaper model is the cheaper way to finish a task depends on how many steps it needs, which is why we measure that on fixed tasks rather than from traffic like this.
- Cache is the second lever. Agents resend most of their context every turn. Across our developer-days the share of input served from cache rose from 77% in May to 93% in September, and what we paid per million tokens sent fell 62% from May to July. Switching models mid-session throws that cache away, so a router has to count the cost of a cold cache before it switches.
How we did it, and the limits
- Traffic is our own team's development work, not customers'. Five months, several agents and tools (Claude Code was about 9% of requests; the rest came through OpenAI-compatible clients).
- The routing improved over the period, so the early months cost more per token than the late ones.
- List prices as of November 5, 2026, no volume discounts. Claude cache writes before November are estimated at 6.6% of the Claude prompt, priced at the 5-minute write rate; the other providers don't report writes separately.
- We didn't grade the answers in this data: it shows what was spent, not what got solved.
If you want to know what your own team sends, the cheapest first step is to put every developer on their own key for a week and look at the bill per person. CodeRouter does that and the routing; its Claude Code pricing page compares the plans.
Keep reading
Where a coding agent's bill goes: output is under 10% of it
385 developer-days of our own team's coding-agent traffic at list prices: output is under 10% of the bill, the most expensive tenth of days is over half of it, and heavy days cost more per request, not only more requests.
Long prompts are where an inference node loses money: 1K, 8K and 16K input tokens on one H100
We measured how much one H100 can serve within a latency target as prompts grow from about 1K to 8K and 16K input tokens (Qwen3-30B-A3B FP8, vLLM, no prefix reuse). Capacity fell from 11.5 to 1.89 and 0.73 requests per second, because the first-token deadline caps how many long prompts the GPU can prefill at once. At a flat input price, long uncached prompts earn less than the GPU costs.
What a prompt cache is worth: the same H100 served 82% more requests at a 90% cache hit rate
We served Qwen3-30B-A3B-Instruct-2507 FP8 on our production H100 with vLLM and repeated the same latency-target search with 0%, 50%, 75% and 90% of every prompt drawn from shared prefixes. vLLM's own counters showed cache hit rates of 0%, 49%, 74% and 89%. Capacity rose from 11.5 to 21.0 requests per second, and revenue per GPU-hour from $10.37 to $18.84 at flat prices. With cached input billed at a quarter of the price, the node still earns more and the customer pays far less.