← Retour aux guides

Cache Reads in 2026: When Reused Prompts Pay Off

Use cache reads when multiple requests reuse a substantial, unchanged prompt prefix within the cache lifetime. Instead of processing that prefix again, the provider reuses saved computation and bills eligible tokens at its cached-input rate. This is not response caching: the model still generates a fresh answer, and output tokens remain separately billable. ([developers.openai.com](https://developers.openai.com/api/docs/guides/prompt-caching))

Which workloads should you cache?

For a 2026 implementation, start with repeated context rather than simply looking for long prompts. Good candidates to benchmark include:

• Coding agents: repeated project instructions, tool definitions, and stable repository context across an editing session.
• Document Q&A: several questions about the same contract, report, or manual, with the document before the changing question.
• Classification and extraction: a shared policy, schema, and example set followed by a different record on each request.

These workloads give a stable prefix several opportunities to earn back its initial processing or cache-write cost. Anthropic specifically identifies coding assistants, document processing, and detailed instruction sets as caching use cases. ([platform.claude.com](https://platform.claude.com/docs/en/build-with-claude/prompt-caching))

Calculate savings after the first write

A cheap cache-read rate does not automatically make caching economical. Include ordinary input, cache creation, cache reads, and output in your estimate. Some providers charge a premium for writing cached context; longer retention can increase that premium. Use your relay's actual billing rates, not an upstream discount copied from another model. ([platform.claude.com](https://platform.claude.com/docs/en/build-with-claude/prompt-caching))

Illustrative calculation: assume 20 requests each contain a reusable 12,000-token prefix and 1,000 new tokens. Suppose ordinary input costs $1 per million tokens, cache writes $1.25, and reads $0.10. Without caching, input costs $0.26. With one prefix write and 19 successful reads, input costs $0.0578: approximately 78% less. These are hypothetical rates, and output charges are excluded.

For your own break-even test, compare the extra write expense with the savings from realistically expected reads—not an assumed 100% hit rate.

Structure requests so reuse actually happens

• Put stable material first. Keep instructions, examples, and reference documents ahead of changing questions. Place timestamps and request-specific metadata after the reusable section. Preserve content and ordering. ([platform.claude.com](https://platform.claude.com/docs/en/build-with-claude/prompt-caching))
• Choose the correct cache boundary. On supported Claude requests, an explicit cache_control marker belongs on the last stable content block. Marking a changing suffix can repeatedly create entries that never get read. ([platform.claude.com](https://platform.claude.com/docs/en/build-with-claude/prompt-caching))
• Check model-specific behavior. Minimum cacheable length and eligible boundaries vary. A shared prefix alone does not guarantee reuse; confirm the endpoint's supported caching controls rather than assuming every model caches identically. ([developers.openai.com](https://developers.openai.com/api/docs/guides/prompt-caching))
• Match retention to request spacing. For Claude, five-minute and one-hour options have different write costs. Choose longer retention only when expected later reads justify it. ([platform.claude.com](https://platform.claude.com/docs/en/build-with-claude/prompt-caching))

Measure tokens and money, not warm feelings

Run a cold request, then several requests with the same prefix and different questions. DeepSeek documents that a common prefix may only become reusable after multiple requests, so a single follow-up is not always a sufficient test. Inspect prompt_cache_hit_tokens and prompt_cache_miss_tokens, and remember that cache availability is best-effort. ([api-docs.deepseek.com](https://api-docs.deepseek.com/guides/kv_cache/))

For OpenAI Responses, inspect usage.input_tokens_details.cached_tokens and any reported cache-write tokens. Calculate token hit rate as total cached tokens divided by total input tokens. Track realized cost alongside latency: a high hit rate is useful only if the complete workload becomes cheaper. Avoid double-counting cached tokens as ordinary input. ([developers.openai.com](https://developers.openai.com/api/docs/guides/prompt-caching))

Make cache-aware savings practical with 59API

59API is a low-cost, pay-as-you-go option with published input, output, cache-write, and cache-read prices. Benchmark Claude Sonnet 5.5 or DeepSeek V4 Pro against your actual repeated-context workload, then reconcile usage with the bill. ([59api.com](https://59api.com/pricing))

Its official-quality model access, Claude Code, Codex, Gemini CLI, and OpenAI SDK integrations make adoption convenient; it also offers a referral rebate. Follow the setup instructions for your chosen protocol. If you want to test the economics, sign up for 59API and start with one representative session. ([59api.com](https://59api.com/))

Bottom line: prioritize caching when context is stable, reuse is frequent, and measured read savings exceed creation costs. For one-off or constantly changing prompts, test shorter context before investing in cache engineering.

Tarifs · Docs