Prompt caching cuts what you pay for repeated input

Prompt caching rests on a very simple observation. Most of what you send to a model is identical from one call to the next. Instructions, examples and reference documents go out again with every request. Providers agree to remember that repeated part and bill it at a fraction of the price. For regular use, it is the easiest saving on the market.

Easy does not mean automatic everywhere or always profitable. Each provider has its own rules, timings and minimums. The mechanism comes first in plain words, then the exact conditions provider by provider, then the writing rule that separates a cache that pays from a cache that sits idle.

01Key takeaways

• The principle is that the identical part of your requests is remembered by the provider and then billed at a fraction of the input price.
• At OpenAI, it happens automatically and cached input costs a tenth of the normal rate, per the price list of October 16, 2026.
• At Anthropic, you ask for it explicitly. Reads cost 0.1x, writes carry a 1.25x surcharge and the memory lasts five minutes, renewed on each hit.
• The golden writing rule puts everything fixed at the start of the prompt and everything variable at the end, without exception.
• You can check the savings in black and white, because API responses count the tokens served from the cache.

02Prompt caching in plain words

On every call, the model rereads your entire request, including the parts it has already read a hundred times. That rereading is paid for in input tokens. Caching changes the deal. The provider keeps the start of your request in memory for a few minutes. If the same start comes back, it processes it at a reduced price instead of billing it at the full rate.

This lever holds a prime spot in the main guide to AI without a subscription because it asks for no sacrifice. You keep the same model, the same answers and the same quality, while only the input line on your statement gets thinner. The overview of cost-saving levers ranks it among the first moves to make, right after choosing the model.

03Why the bill drops, reads versus writes

The cache has two moments. The write comes first. On the first pass, the provider stores your prefix, for free at some providers and with a slight surcharge at others. The read comes next. On later passes, the recognized prefix is billed at the reduced rate, a tenth of the input price at the two big American providers. Profitability is therefore a matter of repetition, since the more often the same start comes back within the memory window, the faster the write pays for itself.

The order of magnitude deserves a clear statement. Input often makes up the overwhelming majority of tokens in a tool-driven request, with instructions and context far outweighing the question of the day. Cutting that mass to a tenth really moves the bill. The gap between input and output explains why the two directions of billing don't weigh the same.

04Provider by provider, as of October 16, 2026

Provider	Activation	Cached rate	Memory
OpenAI	automatic	input ÷10	a few minutes
Anthropic	explicit (tag)	read 0.1x (0.05x on the 5.5 models), write 1.25x	5 min, renewable
DeepSeek	automatic	cached input at $0.003 to $0.006/M	managed by the provider
Google	implicit or explicit	large discount, see official docs	depends on the mode

OpenAI, the cache that works on its own

There is nothing to switch on. The platform detects repeated prefixes above a certain size and applies the reduced rate by itself, a tenth of the input price on the official price list. Your only job is to write requests that suit it, which means following the golden rule described further down. The cached-tokens field in the response confirms that the mechanism is running.

Anthropic, the cache you ask for

At Anthropic, you declare the cache yourself. A tag in the request marks the end of the zone to remember, with up to four breakpoints per request. The official docs list reads at 0.1x the input price against writes at a 1.25x surcharge, with a five-minute memory extended on each reuse and a one-hour option with a pricier write. A minimum token count applies depending on the model. You get more control in exchange for one more setting. The examples in the docs can be copied in a few minutes.

DeepSeek and Google, two schools of caching

DeepSeek applies its cache automatically and shows it right in its price list. Recognized input drops to $0.006 per million tokens at peak hours against $0.30 for full-price input, with both rates halved off-peak, one of the most generous ratios on the market. Google offers both schools, implicit and explicit, with a large discount on remembered tokens. The size and duration conditions shift with the mode, so the official docs are the reference. The side-by-side provider price lists keep the figures up to date.

05The golden rule, fixed first and variable last

The cache only recognizes identical beginnings, because everything works by prefix. The practical consequence fits in one sentence. Put everything that doesn't change at the top of the request and everything that changes at the end. Instructions, tone, examples and reference documents come first, while the question of the day, the text to process and the date always go last.

The mistake that ruins everything is a variable slipped in at the start. A timestamp, a first name or an ID on the first line makes every request unique in the eyes of the cache. The reduced rate never applies again. The statement then keeps its original weight with nothing to flag it, month after month and in complete silence. Reread your templates with two checks in mind, namely what changes from one call to the next and whether it is placed at the end.

06A worked example with 4,000 tokens of instructions

Take a customer assistant built on a tool. Its 4,000 tokens of instructions and documentation go out with every conversation, for a thousand conversations a month. Without caching, that repeated part weighs four million full-price input tokens. On a budget model billed $0.75 per million input tokens as of October 16, 2026, that comes to $3 a month just to reread the same instructions.

With caching at a tenth of the rate, the same rereading falls to around $0.30. That puts $2.70 back in your pocket each month without changing a comma of the service. Apply it to a premium model or to ten thousand conversations and the same math gives back tens of dollars. The mechanism is linear, so your statement supplies the factors and a calculator does the rest. This is the typical saving from caching, modest in absolute terms at small volumes and structural once repetition sets in.

07Caching and conversations, where history benefits too

Dialogue is the natural home of caching. On each turn, the whole history goes out again as input, so the start of the conversation becomes a repeated prefix by construction. Providers with automatic caching remember it on their own. The tenth exchange, which carries the previous nine along with it, then pays for them at the reduced rate instead of the full input price. The longer the dialogue runs, the more the discount counts.

Two habits protect that benefit. First, don't switch models in the middle of a dialogue, since each model has its own memory. You choose the tier at the start of the work, as the page on routing recommends. Second, don't rewrite the first messages, because any edit upstream invalidates the memory of everything that follows. A conversation that moves straight ahead caches itself, while a conversation tampered with upstream gets billed at full price on every turn that follows.

08Three myths to put away

The first myth claims the cache keeps your data for training. It is a technical memory of a few minutes meant to avoid a reread, separate from data-use policies, which are set elsewhere and described on the providers' dedicated pages. The second myth claims the cache freezes the answers. It only remembers the reading of the input, so generation stays whole and your answers vary exactly as they did before the setting.

The third myth calls caching a developer thing. That was true in the early days and has stopped being true. Automatic caches work for anyone who uses a tool with stable templates, without a single line of code. The only useful skill is editorial, knowing how to place the fixed part before the variable part in each of your working templates. The most technical setting on the subject remains the Anthropic tag, within reach of anyone who can copy an example from the docs.

09When caching pays off and when it doesn't

Three conditions make it profitable. Repetition comes first. Memory is counted in minutes at most providers, so use spread out over hours rewrites the cache each time and pays any surcharge without ever getting the discount. Size comes next, because below the provider's minimum token count, often around a thousand, the prefix is not remembered at all. Stability comes last, since a template edited every week invalidates its remembered version with each change.

The ideal candidate follows from that. It is an assistant or a production chain that runs request after request on the same large template, in close sessions with a stable prefix. The occasional user with short, spaced-out requests gains nothing. A better lever for that profile is to route each task to the right model or to shorten your input templates, the natural complement to caching. The cache reuses what is identical, while slimming down reduces the whole.

10Checking that it works, in black and white

You don't have to take anyone's word for it. API responses detail usage, with a counter for tokens served from the cache. A counter at zero on requests that should repeat points to an unstable prefix, one that is too short or calls spaced too far apart. A well-filled counter confirms the discount is landing. Tools that display their usage show the same thing without opening a line of code, right on their tracking screen.

The final proof shows up on the monthly statement, where the input line for the model concerned should drop from the first month of a well-tuned cache. Reading your statement continuously lets you compare before and after. To predict the gain instead of observing it, pricing a single call with and then without the discount gives you the difference in two multiplications.

11The checklist for a cache that pays

1. Identify the templates you call several times an hour with a large, stable prefix.
2. Reorganize each template with the fixed part at the start, the variable part at the end and no timestamp at the top.
3. At Anthropic, place the cache tag at the boundary between fixed and variable. Elsewhere, let it happen.
4. Check the cached-tokens counter on a few responses, then on the month's statement.
5. Freeze the templates that work, because every edit to the prefix costs you a cache rewrite.

OpenTahr's tools reuse stable templates and the account is free. The fixed part comes back identical from one generation to the next, so the provider's discount lands on your key and not in a middleman's pocket. That is the BYOK spirit applied down to the last token. The saving belongs to the person who pays the bill.

12Frequently asked questions

What is prompt caching?

It is a mechanism used by AI providers that remembers the identical part of your requests, the prefix, for a few minutes and bills it at a reduced rate when it comes back. Repeated instructions and documents stop costing full price on every call. Only the part that changes from one call to the next is still billed at the normal input price.

Is caching automatic?

At OpenAI and DeepSeek, yes. Repeated prefixes are detected and discounted with no setting needed. At Anthropic, you declare the cache with a tag in the request, which gives more control in exchange for a technical step. Google offers both modes. Each provider's official documentation is the reference.

How much does caching save?

On the cached part, input drops to a tenth of the rate at OpenAI, the same as reads on most Anthropic models (a twentieth on Opus 5.5 and Sonnet 5.5), per the price lists of October 16, 2026. DeepSeek shows an even lower cache rate in its price list. The total gain depends on the weight of your repeated prefix. A large, frequent prefix can transform the input line of your statement from the first month of correct setup.

Why isn't my cache kicking in?

There are three usual suspects. A variable placed at the start of the template makes every request unique, the prefix may sit below the provider's minimum token count or the calls may be spaced too far apart for a memory of a few minutes. The cached-tokens counter in API responses points to the culprit after a few side-by-side tests.

Transparency. Prices and mechanisms were recorded on October 16, 2026 from the official price lists and documentation cited as sources. These conditions change quickly. The official pages are the reference on the day you read this. Minimum token counts and memory durations vary between models from the same provider. None of the providers mentioned pays us.

13Sources

1. OpenAI official price list, cached input included
2. Anthropic official documentation on prompt caching
3. DeepSeek official price list, cache hits included
4. Anthropic, Claude API pricing documentation (all models)