12-Hour Caching in the OpenAI API: When It Cuts the Cost of Long Prompts

For an agent that calls an API several times during a workday, repeatedly sending long instructions affects cost. On October 20, 2026, OpenAI added a choice of a 12-hour caching period to the Responses API: shared instructions, tools, and context can remain available for reuse across requests made several hours apart. OpenAI lists the write rate as 2.5 times the standard input-token price; this is the full write rate, not an additional surcharge on top of it. Savings depend on prefix reuse and the price of reading cached tokens. The announcement in OpenAI’s changelog is dated October 20, 2026.

This retention period is designed for multi-step workflows: for example, an agent can analyze documents in the morning and continue the task later using the same instructions and tools. When deciding whether to enable the 12-hour period, compare write costs with the cost of repeated reads and consider how many requests actually reuse the same prefix.

What gets cached

Prompt caching reuses a matching initial segment of the input. Subsequent requests must keep it identical; changing data should go after the fixed portion. The OpenAI prompt-caching guide says that for GPT‑5.6 and later models, you can set a TTL of 30m or 12h in the Responses API. Twelve hours is the minimum period for which an entry is expected to remain available for cached reads; it is not a promise that it will be deleted exactly after 12 hours. Availability and settings depend on the model.

System instructions, tool definitions, and stable processing rules are useful in a fixed prefix. Put the current question, task identifiers, and fresh data later. If you change earlier parts of the request, the matching prefix will be shorter, which may reduce the number of tokens reused.

How to estimate the break-even point

Let the stable prefix contain P tokens, be sent N times, and let the standard input-token price be C. Let the cached-read rate for the selected model be R. With one write and a cache hit on every subsequent request, the cost for that prefix will be approximately 2.5PC + (N−1)PR. Without caching, sending it would cost NPC. This estimate covers only the stable prefix: account separately for the changing part of the request, cache misses, and additional writes. The read rate depends on the model; for example, the documentation lists 0.05 times the standard input-token price for GPT‑6.1 Sol and 0.1 for GPT‑5.6 and later models.

In this simplified model, caching starts to save money on a reused prefix when 2.5C + (N−1)R < NC. The actual break-even point depends on real cache hits, repeat writes, and the specific pricing plan. If requests are infrequent, instructions change often, or the prefix is unique each time, the additional write costs may outweigh the savings on reads.

Test it on your workload

1. Set a baseline. Use typical requests, the stable-prefix length, intervals between calls, and costs without a 12-hour TTL.
2. Separate fixed and changing content. Keep shared instructions and tool schemas at the beginning, and put user data and the current task after them.
3. Compare like-for-like requests. Count writes, cached input tokens, and total costs for the selected model and retention period.
4. Assess the full workflow. Account for cache misses, repeat writes after expiration, and cases where a changed prefix prevents reuse.

API response metrics help verify the actual number of cached input tokens and writes; the reporting details depend on the model. The configurable 12-hour period suits a large, stable prefix reused at intervals of several hours. For short or rarely repeated requests, first measure writes, cache hits, and total cost on your own traffic.