Prompt caching is just a bookmark.

“Can we make the Artificial Intelligence (AI) cheaper without making it worse?” Every team running AI at any real volume ends up asking it. One of the most dependable answers has a dull name and an outsized payoff: prompt caching. It's the difference between a model that re-reads your entire standing context on every call (and pays for it every time) and one that reads it once, then picks up where it left off.

Why do you pay for the same words twice?

Every time you call a model you send the whole prompt again: the system instructions, the brand guidelines, the big reference document, the few worked examples, plus the one new thing the user asked. The model reads all of it from the top, and, as the token brief laid out¹, you're billed per token, in and out. The catch is that most of that prompt never changes. The same long instruction block goes out call after call, and you pay full price to reprocess it every single time. Prompt caching targets exactly that waste: it lets the model, in Anthropic's words, resume from specific prefixes in your prompts², reusing the work it already did on the unchanging part instead of redoing it.

How does the model skip the re-read?

You mark the stable run of text at the start of the prompt as cacheable. The first call reads it and stores the result (that storage carries a small premium). Every later call that begins with the same text reuses it for a fraction of the price. Nothing about the answer changes; only the bill and the wait do.

What changes on the bill?

• •On some platforms the saving is already happening. OpenAI says caching works automatically for eligible requests, with no code changes required³, for any prompt 1024 tokens or longer³, on all recent models, gpt-4o and newer³. Google's Gemini does the same by default: implicit caching is enabled by default for all Gemini 2.5 and newer models⁴, passing the savings on automatically. On Anthropic's platform you turn it on explicitly, marking which prefix to keep. So part of the win may already be in your invoice; the rest is one setting away.
• •The discount is steep — but only on the repeated part. Anthropic prices a cache read at 0.1 times the base input tokens price²: a tenth. The trade-off is a small premium to store it in the first place. A five-minute cache write costs 1.25 times the base input tokens price². So the first call is a touch more expensive and every reuse after it is about 90% off the input for that block. It pays for itself the moment the same context is used more than once.
• •It's short-lived, on purpose. Anthropic's cache has, by default, a 5-minute lifetime², though it's refreshed for no additional cost each time the cached content is used². Steady traffic keeps it warm; an idle gap lets it lapse. That makes caching a lever for bursts of activity (a live chat mid-conversation, a batch of documents run back-to-back) and close to useless for a call that fires once an hour.
• •It only rewards structure. Caching matches a prefix, the run of text at the very start of the prompt, so the savings appear only when the unchanging content comes first and the variable user input comes last. Flip that order and there's nothing stable to reuse. There's also a floor: OpenAI caches prompts 1024 tokens or longer³ and Anthropic sets a similar per-model minimum, so short prompts don't qualify at all.

The “so what” — for anyone serving tech clients

• •Build the prompt stable-part-first. When you scope an AI feature, put the unchanging context (brand guidelines, the product doc, the worked examples) at the top, and the client's input at the end. That one ordering choice is what makes caching possible, and on a chatty, high-volume feature it takes a real bite out of the input cost. It's free to ask for at build time and painful to retrofit later.
• •Quote it honestly, in tokens. Price the feature the way the token brief describes¹, then say which of those tokens are cacheable and which aren't. The saving lands where the same big context is hit again within minutes, and barely at all on one-off calls. And when a client worries their reference material is being reused behind the scenes, you can point to the platform's own rule: OpenAI states plainly that prompt caches are not shared between organizations³.