Why is my Claude API bill so high? 9 things to check

1. Thinking you never see is billed as output

On current models thinking is on by default, and on Claude Opus 5.5 it can't be switched off. The thinking happens and is billed the same whether or not you display it, and on the newest models the default display shows nothing, so it is easy to miss. Thinking tokens are counted inside output_tokens, at the output price, which is five times the input price. usage.output_tokens_details.thinking_tokens tells you how much of the output was thinking.

Fix: use the effort setting (output_config.effort). It controls how deeply the model thinks and how many tokens it spends overall. Simple tasks such as classification or short chat often do fine at low. Measure quality on real requests before and after. More on thinking costs.

2. The prompt cache never hits

Caching works on an exact prefix: any change anywhere early in the prompt makes everything after it miss. A timestamp or request ID in the system prompt, JSON written with keys in a different order, or a tool list that changes between calls will each stop the cache from ever hitting, without any error. Prompts shorter than the model's minimum cacheable length (between 512 and 4,096 tokens, depending on the model) are not cached either.

Check: if cache_read_input_tokens stays at zero on requests that share a long beginning, something is changing the prefix. Put stable content first and anything that varies after the last cache breakpoint. The caching break-even math shows when caching pays off.

3. Every turn sends the whole conversation again

The API keeps no memory between requests, so a chat or agent loop sends the full history every time. Turn 30 pays for turns 1 to 29 again as input. Without caching, the cost of a long conversation grows much faster than its length.

Fix: cache the conversation so earlier turns are read from the cache at a fraction of the price, keep tool results short, and start fresh conversations when the old context no longer matters.

4. Cache writes cost more than plain input

Writing to the cache costs 1.25 times the input price for the 5-minute cache and 2 times for the 1-hour cache. If you write a lot to the cache and rarely read it back, caching costs you more than it saves. The 1-hour cache only pays off when the same prefix is read at least twice.

5. Fast mode doubles the price

Fast mode on Claude Opus 5.5 costs $8 per million input tokens and $40 per million output tokens, twice the standard rate. If usage.speed says "fast" on requests where nobody is waiting, you are paying double for speed you don't need.

6. Work that could wait isn't batched

The Message Batches API runs requests asynchronously at half the price. Nightly summaries, bulk classification, evaluations and backfills rarely need an answer in seconds. Batch prices and limits.

7. A bigger model than the job needs

Claude Opus 5.5 costs $4 / $20 per million input / output tokens; Claude Sonnet 5.5 costs $2 / $10, half as much; Claude Haiku 5.5 costs $0.10 / $0.50. But judge cost per finished task, not per request: a cheaper model that needs more retries or turns isn't cheaper. Lowering effort on the model you already use is often worth trying first.

8. Long prompts on Haiku 5.5

Claude Haiku 5.5's $0.10 / $0.50 price covers prompts up to 100,000 tokens. Above that it is $0.50 / $2.50, five times as much. A pipeline that occasionally sends a huge document to Haiku can cost far more than expected.

9. Paying twice for the same answer

Retries after timeouts, double-clicks and pipelines that re-run can send the same request more than once. The official SDKs also retry some failed requests automatically (twice by default). Each repeat that completes is billed as a new request. How to spot duplicate AI API charges has a script that finds them.

Smaller items that also change the price: US-only inference (inference_geo: "us") adds 10%, and web search is charged per search on top of tokens.

See where your own money goes

Save each response's JSON as one line in a file (in Python, message.to_json() gives you that line), then run the script on the file. It prices every response at Anthropic's standard rates, splits the cost into new input, cache writes, cache reads, output and thinking, and lists the requests that sent a lot of new input with no cache reads. It prints numbers only and sends nothing anywhere. (Download it, or get it with the other scripts on GitHub.)

python3 claude_api_bill_check.py responses.jsonl

Example output (made-up data: 400 responses, where the first 150 sent a 12,000-token system prompt without caching):

400 responses, $14.8819 at standard API rates

Where the money went:
  new input                    $    7.5466   50.7%
  output (not thinking)        $    3.5290   23.7%
  thinking (billed as output)  $    3.2231   21.7%
  cache reads                  $    0.5232    3.5%
  cache writes (5 min)         $    0.0600    0.4%
  cache writes (1 hour)        $    0.0000    0.0%

By model:
  claude-opus-5-5              $   12.7058
  claude-sonnet-5-5            $    2.1761

Prompt tokens read from cache: 57.9%
150 responses sent 10,000+ new input tokens with no cache reads (lines: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ...)

In this example, half the bill is new input, and the 150 uncached requests are where it came from. Thinking is over a fifth of the bill, so effort is worth testing too.

We tested the script on hand-checked cases: its per-response prices match our tested per-request cost function to the cent, it skips lines that aren't responses, and it lists anything it can't price instead of counting it as free: models it has no price for, fast mode on models other than Opus 5.5, and Haiku 5.5 prompts over 100,000 tokens. Batch and US-only prices are not applied.

Or let something watch the bill for you

NeverPayTwice is a small app we make. It tracks your AI usage and its cost per day and per model against a monthly budget you set, flags every time you paid again for something you had already bought, and keeps a receipt for each AI purchase. It runs on your own computer; nothing is uploaded and API keys are never stored. Mac, Windows or Linux, $9 one time.

Sources: Anthropic's API pricing page and API documentation on thinking, effort, prompt caching, fast mode and message batches, checked November 15, 2026. Prices can change; check the current pages if something doesn't match.