Claude Code Prompt Caching: The 20x Rule That Decides Your Bill

Your last Claude Code message may have cost 20x more than the one before it. Not because of what you typed — because of what expired while you stepped away.

Prompt caching is the single largest lever on a Claude Code bill, and it is almost entirely invisible. There is no warning when it lapses, no line in the interface that says the next message will be expensive, and no obvious relationship between what you did and what you paid.

Here is the full breakdown, concept by concept — what you are actually billed for, why the cache exists, and the three clean ways to reset when it is gone.

The short version

• Tokens are the bill. Every reply resends the whole thread.
• The cache is the discount — reading it costs 0.1x, rewriting it costs 2x. That gap is the 20x.
• The clock is the only real risk. Claude Code holds a one-hour cache; going quiet longer kills it.

1. Tokens are the currency

One word is roughly one token, and nothing you send is free — including the parts you did not consciously send.

The asymmetry that matters: output costs 5x input. On Opus that is $5 in and $25 out per million tokens. So a verbose response is five times more expensive per token than the context that produced it, which is a good reason to ask for concise output on routine work.

But output is the smaller problem, because output is bounded by what you asked for. Input is not.

2. Every reply resends the whole thread

This is the fact that surprises people, and everything downstream follows from it.

The API is stateless. It remembers nothing between messages. There is no session on the other end holding your conversation. Each request has to carry everything the model needs to answer.

Which means your 200th message re-sends messages 1 through 199 as fresh input. Not a summary of them — all of them, in full, every single time.

A long working session therefore has a cost curve that rises with every exchange, regardless of how short your latest message was. Typing “yes” at message 200 is not a cheap request.

3. Prompt caching is the discount

Caching exists precisely to defuse that. Rather than reprocessing the entire thread at full price, Claude reads a held copy of your thread at one tenth the input price.

Writing that copy is not free — it costs 1.25x the normal input rate, or 2x for the one-hour version. But you pay it once and then read cheaply for as long as the copy lives.

So the economics of a long session are: one expensive write, then many very cheap reads. That is a good trade, and it holds right up until the copy disappears.

4. The cache has a clock

Claude Code holds a one-hour cache. Go quiet longer than that and it dies, silently.

Time is not the only thing that kills it. Switching your model, your tools, or your settings kills it instantly — because the cached copy was written against a specific configuration, and changing the configuration invalidates it.

This is worth internalising, because it makes some very ordinary behaviour expensive. Swapping models mid-session to “save money” on a simple question throws away the cache and costs you the rebuild. So does adding a tool halfway through. So does lunch.

5. Why it is exactly 20x

The arithmetic is short and worth doing once.

• Cache alive: you pay 0.1x to read it.
• Cache dead: you pay 2x to write it again.

2 divided by 0.1 is 20. That gap is the 20x, and it applies to the entire thread, not to your last message.

Made concrete: a 500K-token thread costs about 50 cents to read while the cache is alive, and about 10 dollars to rebuild once it is not. Same conversation, same next question, twenty times the price — decided entirely by whether you were away for fifty minutes or seventy.