aiapicostcalcUnit economicsPricesBrandsCompareBenchmarksSkills & PluginsFind my modelGuidesChanges

Claude Code token cost: what one task really costs

Short answer: Claude Code burns about 60K input tokens (70% cached) and 4K output tokens per typical task, so one task costs $0.0810 on Grok 4.7. At 200 tasks a month that is $16.20; without caching the same task would cost $0.1440. Evidence: documented.

Last verified 2026-11-18 · Sources: src/tools.json (Claude Code token basis, documented) and src/prices.json (rates) · Report an error

By Shangyi Duan · Tool token basis: Documented

Tool token data: src/tools.json (reviewed 2026-11-05) · Model rates: src/prices.json (checked 2026-11-18) · Evidence: Documented

Cost per task, three price points

One row per scenario from our tool data. The three price columns price the identical token counts on the cheapest, mid and premium reference models, so the difference is the model rate, not the workload.

ScenarioInput tokensCached inputOutput tokensCheapest current modelMid-tier reference modelPremium reference model
Light task
one short request with a small context and one or two tool calls
15K50%1,500$0.00158$0.0278$0.3150
Typical task
one coding or agent task with several tool calls and a medium context
60K70%4K$0.00422$0.0810$0.8440
Heavy session
a multi-turn agent session with a large repo or long history; input counts all tokens re-sent across turns
250K80%12K$0.0130$0.2720$2.60

Rates: input $2 / cached $0.5 / output $6 per 1M on Grok 4.7. Prices checked 2026-11-18.

Monthly budget

Scenario at 200 tasks / monthCheapest current modelMid-tier reference modelPremium reference model
Light task$0.3150$5.55$63.00
Typical task$0.8440$16.20$169
Heavy session$2.60$54.40$520

At 200 tasks a month, one task at the typical size costs $0.0810 on Grok 4.7, so $100 covers about 1235 tasks. The same budget buys 118 tasks on the premium reference and 23697 on the cheapest one.

Recalculate this page in your browser

Server-rendered from the typical task on Grok 4.7 at 200 tasks a month. Change a field to recalculate; nothing is sent anywhere and the formula is the one under Method.

Cost per task
$0.0810
Cost per 1,000 tasks
$81.00
Monthly
$16.20

Where the tokens go

The provider basis behind these numbers

Anthropic's cost docs report an enterprise average of about $13 per developer per active day and $150-250 per developer per month, and show a real session breakdown of 1.2k input, 5.3k output and ~990k cache tokens ($0.55). The tiers split that usage into a 15k-token light task, a 60k-token typical task and a 250k-token heavy session, with 50-80% of input served from prompt cache; the docs' mature-session cache example reports 91% of input tokens from cache. The monthly total assumes 200 typical tasks per developer, while Anthropic's enterprise average also includes heavier multi-session and parallel-instance use.

What caching is worth here

Our data does not assume a cached prefix for this tool (70% cached share), so the task price above is already the uncached input price. If the tool does repeat a stable prefix, adding it to the provider cache cuts the input side to $0.5 per 1M on Grok 4.7.

How to reduce it

Each tip changes a different part of the formula: caching changes the input rate, trimming history changes the input count, and routing simple steps to a cheaper model changes the rate for part of the work.

Sources and evidence

SourceRead onWhat it establishes
code.claude.com2026-11-04Enterprise cost averages ($13/active day, $150-250/month), a session token breakdown, prompt-cache statistics and token-reduction guidance.
code.claude.com2026-11-04What loads into context at startup, how compaction works, and the 5k-token per-skill / 25k-token total caps on re-injected skill bodies.
code.claude.com2026-11-04Documents MCP tool search and the default deferral of tool definitions to keep context small.

Evidence label: Documented

Anthropic's cost docs report an enterprise average of about $13 per developer per active day and $150-250 per developer per month, and show a real session breakdown of 1.2k input, 5.3k output and ~990k cache tokens ($0.55). The tiers split that usage into a 15k-token light task, a 60k-token typical task and a 250k-token heavy session, with 50-80% of input served from prompt cache; the docs' mature-session cache example reports 91% of input tokens from cache. The monthly total assumes 200 typical tasks per developer, while Anthropic's enterprise average also includes heavier multi-session and parallel-instance use.

Method

The formula

Cost per task = (uncached input × input rate + cached input × cached rate + output × output rate) ÷ 1,000,000. Rates are the standard list prices in the price table (checked 2026-11-18); token counts come from src/tools.json (tool data reviewed 2026-11-05).

Why three reference models

The columns are the cheapest, median and most expensive current models by the cost of one typical agent task, named above so you can check each rate. They are a range, not a prediction of which model Claude Code uses.

What the monthly figure assumes

200 tasks a month (the tasks-per-month field in our tool data), the same count for every scenario, at the standard rate with no batch discount. A heavy session can count as several tasks, so replace the number with your own before you put it in a budget.

Official links

Related skills & plugins

Other entries in the AI coding agents category. Each name links to its token-cost page or its official site.

Related models

The three reference models in the cost table, with their full price tiers.

More

Related

Questions

How much does Claude Code cost per task?

One typical task costs $0.0810 on Grok 4.7, $0.00422 on the cheapest reference model (GPT-6 Luna) and $0.8440 on the premium reference (GPT-6 Cyber). The spread is the model rate: the token counts are identical in all three columns.

What does Claude Code cost per month at 200 tasks?

$16.20 a month on Grok 4.7 at the typical task size. Without the 70% cached input assumption it would be $28.80. Per 1,000 tasks the token bill is $81.00.

Why does Claude Code use so many input tokens?

Claude Code re-sends the full conversation on every request, and each tool call adds another request carrying that batch of tool results. System prompt, CLAUDE.md, skill descriptions, tool definitions and extended-thinking output all count, and auto-compaction rewrites history so the prefix has to be cached again. The token shape is 60K input tokens (70% cached) against 4K output per typical task; input is resent every step, output is not.

Are the Claude Code token numbers measured or estimated?

The evidence label is "Documented". Anthropic's cost docs report an enterprise average of about $13 per developer per active day and $150-250 per developer per month, and show a real session breakdown of 1.2k input, 5.3k output and ~990k cache tokens ($0.55). The tiers split that usage into a 15k-token light task, a 60k-token typical task and a 250k-token heavy session, with 50-80% of input served from prompt cache; the docs' mature-session cache example reports 91% of input tokens from cache. The monthly total assumes 200 typical tasks per developer, while Anthropic's enterprise average also includes heavier multi-session and parallel-instance use. Sources and read dates are in the table above; if a number is an estimate, the basis says what it assumes, and it is never described as a measurement.

Next step → See every tool cost side by side

Price data last checked 2026-11-18 against official sources · how we verify

Price-change alerts

One short email when a provider changes a price or a promo ends. No spam, unsubscribe any time.