By Justin Wolz
Where Claude token usage lives, how a token becomes a dollar, and what finance and engineering each need to watch.
Claude token usage is the count of input and output tokens your requests consume, and it is what Anthropic bills for on the API. You can see it in the Claude Console, in the usage block of every API response, and in Claude Code with the /usage command.
- A token is the billing unit. Cost is token counts multiplied by a per-model rate, so every cost question starts as a usage question.
- Usage and cost are separate pages. The Console has a Usage page and a Cost page, and engineers and finance tend to want different ones.
- Caps are a separate job. Seeing usage does not limit it. Spend limits and card limits do.
This guide covers Claude API and Claude Code usage. It does not cover consumer Claude subscription limits, which are a different system with its own rules. Everything here is checked against Anthropic's public docs as of November 6, 2026.
How do I check my Claude token usage?
Open the Claude Console and use the Usage page for token counts and the Cost page for dollars. For a single request, read the usage block in the API response. In Claude Code, run /usage to see session token use and an estimated dollar figure.
Which one you want depends on the question. "How much did we spend last month" is a Cost page question. "Why did that one job burn through a million tokens" is a response-level question.
What is Claude token usage?
A token is a chunk of text, usually a few characters to a short word. Claude reads tokens in and writes tokens out, and Anthropic meters both.
Usage splits into four buckets, and the split matters because each bucket has its own price:
Uncached input tokens. The part of your prompt processed fresh.
Cache creation tokens. Prompt content written to the cache so later requests can reuse it.
Cache read tokens. Cached content read back on a later request, at a lower rate.
Output tokens. What the model writes back. Extended thinking is billed as output tokens in Claude Code.
One field name trips people up. In API responses, `input_tokens` counts only the tokens after your last cache breakpoint. The real input size is `cache_read_input_tokens` plus `cache_creation_input_tokens` plus `input_tokens`. If you total only `input_tokens` on a cached workload, you will undercount badly.
Where to check Claude API usage
| Where to check | What it shows | Who uses it | Granularity |
| Console Usage page | Token counts | Engineering | |
| Console Cost page | Dollar spend | Finance | |
| usage block in API response | Tokens for that request, by bucket | Engineering | Per request |
| count_tokens endpoint | Estimated input tokens before you send | Engineering | Per request |
| Usage and Cost Admin API | Usage and cost by key, workspace, model | Eng and finance ops | Usage 1m, 1h or 1d; cost daily |
| Claude Code /usage | Session tokens and an estimated dollar figure | Developers | Per session |
The Console is where finance should live, the response fields are where engineers debug, and the Admin API pipes both into your own dashboards.
The Console pages
Anthropic documents a Usage page at platform.claude.com/usage and a Cost page at platform.claude.com/cost. Start there. If you only need a monthly number for the books, you can stop there too.
The usage block on every response
Every Messages API response carries a usage block with your input token fields and an output token count. Log it. It is the only way to attribute tokens to a feature, a customer or a prompt version, because the Console cannot see your application's structure.
Claude token counter: estimate tokens before you send
To estimate before you spend, Anthropic offers a free token counting endpoint at /v1/messages/count_tokens that returns an estimate and has its own rate limits.
Anthropic notes the system-added tokens it counts are not billed. Newer Claude models also use a tokenizer that yields roughly 30 percent more tokens for the same text, so a count from an older model will not match a newer one.
The Usage and Cost Admin API
For programmatic access, Anthropic's Usage and Cost Admin API exposes a usage report at /v1/organizations/usage_report/messages and a cost report at /v1/organizations/cost_report. Four details to know:
It needs an Admin API key. Regular workspace keys do not work, and it is unavailable for individual accounts.
You can group by key, workspace and model. You can also filter by service tier and other dimensions.
Usage buckets come in 1 minute, 1 hour or 1 day. The cost report is daily only, in USD.
Data typically appears within about 5 minutes. Anthropic asks sustained pollers to hit it at most once a minute.
One caveat: Anthropic labels these two endpoints legacy and points new integrations to its Usage and Cost Analytics API. Check the docs for the current shape before you build on either.
How to check Claude Code token usage
Run /usage in Claude Code to see session token use and an estimated dollar figure computed locally at list price. For API-billed organizations, the Console Cost page is the system of record.
Anthropic's Claude Code cost documentation adds that workspace spend limits apply, that Claude Code creates a dedicated workspace automatically, and that it supports OpenTelemetry export.
For scale, Anthropic's own docs put average Claude Code use at about $13 per developer per active day, or $150 to $250 per developer per month, with 90 percent of users under $30 per active day. Those are Anthropic's figures, not a promise for your team.
Plan limits in the consumer Claude app are outside this guide, because they were not verified against Anthropic's public docs.
How Claude tokens turn into cost
The formula is four lines of multiplication:
cost = (uncached input × input rate) + (cache writes × cache-write rate) + (cache reads × cache-hit rate) + (output × output rate)
Rates change by model and over time, so pull them from Anthropic's pricing page. The full per-model comparison lives in Claude vs OpenAI API pricing compared, so this guide uses one model for illustration.
On Sonnet 5.5, Anthropic lists $2 per million input tokens, $10 per million output tokens and $0.10 per million cache-read tokens (as of November 6, 2026):
| Workload | Input tokens | Output tokens | Estimated cost |
| Small pilot | 1M | 0.2M | $4 |
| Production feature | 10M | 2M | $40 |
| Heavy workload | 100M | 20M | $400 |
| Production feature, 8M of input read from cache | 2M fresh, 8M cached | 2M | $24.80 |
Output tokens cost five times what input tokens do at these rates, so a chatty model costs more than a long prompt. Caching moves the bill sharply: the last row is the second row with most input served from cache, and it costs about 38 percent less. It assumes the cache was already written, so it leaves out cache-write cost.
The Batch API takes 50 percent off input and output for work that can wait. Prices and tier thresholds change, so verify before you budget.
How finance and eng teams monitor and cap usage
Seeing usage and limiting it are different jobs. A split that works:
Engineering owns attribution. Log the response usage block per feature and per customer, and use separate workspaces so the Console and Admin API can group by team.
Finance owns the number. Pull the Cost page or cost report monthly, reconcile it to the card statement, and compare against budget.
Both own the cap. Someone sets the limit and someone gets paged when it fires.
Anthropic gives you two layers of cap. Each usage tier has a monthly spend cap: Start $500, Build $1,000, Scale $200,000, and Custom with no cap.
You can set your own organization limit below the tier cap on the Billing page. Workspaces can have their own limits too, except the default workspace.
Tier cap hit: HTTP 429 with `enforced_spend_limit_reached`.
Your own limit hit: HTTP 400 `invalid_request_error`.
Handle both in your code before they happen in production.
Spend limits are only one layer. Alerts, gateways and daily ceilings each catch something the others miss. The full breakdown, including what each provider's cap does when it triggers, is in LLM API spending limits.
Rate limits are a related but separate control. Anthropic's input-tokens-per-minute rate limit counts uncached input and cache creation but not cache reads, which is one more reason to cache stable prompt prefixes. Rate limit headers (`anthropic-ratelimit-tokens-remaining` and its siblings) tell your code how close it is.
How to cap Claude spend with a Rho corporate card
Finance teams that pay Anthropic with a Rho corporate card can put it on its own card with a recurring monthly limit and a merchant restriction, which sets a payment-side ceiling outside Anthropic's own settings.
Per Rho's help center, a recurring-limit card declines any transaction that would exceed the limit, monthly limits reset on the 1st, and a card can be limited to up to 20 merchants.
Treat that as a ceiling, not as a usage meter. Anthropic's console is where token-level usage lives. A declined charge stops the payment, which is not always the same as stopping the requests.
If you want that ceiling in place, see how Rho corporate cards work.