What's new
Analysis14 Nov 20265 min read

Prompt caching pays only when the prefix gets used again

With the standard Claude cache rates used here, one five-minute write followed by one hit costs 1.35 base units instead of two, while a write that is never reused costs extra.

Prompt caching looks good on a price list, but it only pays when your requests reuse the same opening while the cache is still available. A large document sent once gets no repeat-read saving. A prefix reused often is a different job.

Anthropic's caching guide, read on 14 November 2026, gives standard multipliers of 1.25 for a five-minute write, 2 for a one-hour write and 0.1 for a read, relative to ordinary input. It lists lower read rates for selected models. We use the standard rates below; check the row for your exact model before applying them.

The first write counts as a use

One base unit is the ordinary input cost of your repeated prefix, whether that is a short set of instructions or a large reference document. The arithmetic needs no named model or dollar price.

Without caching, N uses cost N units. With caching, the first use pays the write multiplier and the remaining N minus one uses pay the read multiplier. The table assumes each of those later uses is a successful hit before expiry. It leaves out new input and output, which you still need to budget.

Base-input cost units for one unchanged prefix. Standard Claude multipliers checked 14 November 2026. One write, all subsequent uses hit; no expiry or rewrite.
Total usesOrdinary input5-minute write + hits1-hour write + hits
11.001.252.00
22.001.352.10
55.001.652.40
1010.002.152.90

At two uses the five-minute option costs 1.35 units against two without caching. The one-hour option costs 2.10, so it is still dearer. At three uses the one-hour option would cost 2.20 against three. Duration moves the break-even point as well as the time available to reach it.

Break-even is a count, not a promise

For a write multiplier W and a read multiplier R, caching is cheaper when W + (N − 1) × R is less than N. Rearranging gives N greater than (W − R) divided by (1 − R). At the standard rates above, that means at least two total uses for the five-minute cache, or three for the one-hour cache.

That calculation answers a narrow question. It assumes a single write and reliable reuse. If you change the prefix, miss the eligible length or let the entry expire, the request count alone does not tell you the saving. Usage records should show actual cache writes and actual cache reads separately.

The documentation says a cache hit refreshes its lifetime, so expiry is not a fixed interval after the first request. Your own results log should record the timing of reuse. A typical pause between requests is worth testing as well as a burst sent together.

Stable material goes first

Splitting a prompt into the part shared by the job and the part unique to each request is a design exercise. The stable instructions and reference text go together, with the changing question afterwards. Check the provider's matching rules when implementing this; rearranging a prompt can also change its answer, so rerun your quality checks.

The prefix needs a version. If you edit the instructions, you need to be able to explain why the cache behaviour changed. Account details and document contents have no place in a public log; aggregate token counts and a non-sensitive version label are enough for this comparison.

For a small trial, compare total spend with the uncached equivalent of the same repeated tokens, leaving the unmatched input and output outside the comparison so that a longer answer does not look like a cache failure. Then bring the parts back together for the full job bill.

The right lifetime depends on observed use

The one-hour option is worth pricing when a useful repeat arrives too late for the shorter lifetime. Lasting longer does not make it better by itself. Work out how many writes each option would need under your actual request pattern, then compare the totals.

The fields worth recording are model, prefix version, eligible tokens, writes, reads and time between requests. With them, a claimed discount becomes a saving you can reproduce.