← Retour aux guides

Cut Prompt Costs with Cache Reads: A Practical Guide

Repeatedly sending the same instructions, tools, documentation, or conversation history can make an AI application surprisingly expensive. Cache reads reduce that waste by charging a lower rate when the provider recognizes a previously processed section of the prompt. The key is knowing when repetition is high enough to justify caching and how to structure requests so the cache can actually hit.

1. Identify a stable prompt prefix

Start by separating your request into two parts: a stable prefix and a changing suffix. The prefix might contain a system instruction, coding rules, tool definitions, product documentation, or a long policy file. The suffix should contain the user’s current question, variables, and other request-specific data.

For example, a coding assistant may send the same 12,000-token repository guide on every request while changing only the user’s task. That guide is an excellent cache candidate. A prompt containing a completely different document on every call is not.

• Put stable instructions before dynamic content.
• Keep formatting and whitespace consistent.
• Do not insert timestamps, random IDs, or changing status data into the stable section.
• Keep user-specific details after the reusable prefix.

2. Check whether the request pattern is frequent enough

Prompt caching is most useful when the same prefix is reused during the cache’s lifetime. Estimate the number of requests that will reuse it and the size of the repeated section. A 10,000-token prefix used once has little opportunity to repay its creation cost. The same prefix used 100 times in ten minutes can produce substantial savings.

Use this simple comparison: repeated tokens multiplied by requests, then compare the provider’s normal input price with its cache-read price. Include any cache-write or cache-creation charge in the first request. Pricing and minimum cacheable sizes vary by model, so use the current model pricing rather than assuming every provider uses the same discount.

3. Choose a model and relay that expose the right usage data

Send a small test workload before changing your production architecture. Claude responses commonly identify cache creation input tokens and cache read input tokens. OpenAI-compatible responses may expose cached tokens inside prompt token details. Field names differ, and some relays may pass through only part of the upstream usage object.

59API is a practical low-cost option for this test because it provides pay-as-you-go access to official-quality Claude models, including Opus, Sonnet, Haiku, and Fable, as well as GPT models. You can use the API base URL https://api.59api.com with Claude Code, Codex, or an OpenAI SDK, then compare actual token usage without committing to a large plan.

4. Make the cache boundary deliberate

For providers that require explicit cache controls, place a cache breakpoint after the reusable content and before the changing user message. For providers with automatic prompt caching, the same ordering still helps because the system can recognize a stable prefix. Avoid rebuilding the entire prompt from differently ordered maps or dynamically generated text; semantically identical content may not be byte-identical enough to reuse.

Keep a cache key or version for your stable content. When you update your system instructions or documentation, change the version intentionally. This prevents old instructions from being mixed with new ones and makes cache behavior easier to measure.

5. Verify cache reads in production

Log model name, total input tokens, cache-write tokens, cache-read tokens, output tokens, request latency, and a non-sensitive prompt version. Do not log private customer prompts merely to debug caching. Calculate a cache-read ratio using cache-read tokens divided by total input tokens. A low ratio usually means the prefix changes too often, requests are too far apart, the cache lifetime is short, or the cache boundary is misplaced.

• Run at least one warm-up request.
• Repeat the same prefix with several different user messages.
• Confirm that later responses report cache-read tokens.
• Compare cost per request before and after caching.
• Monitor quality to ensure dynamic instructions were not accidentally cached.

6. Know when not to cache

Do not cache short prompts, one-off requests, rapidly changing data, or content containing secrets that should not remain available in a provider cache. Also avoid assuming that a cache read makes every request cheaper: a small reusable prefix may not meet the model’s minimum size, and a short cache lifetime may cause repeated creation charges.

Once your measurements show a consistent hit rate, route the workload through 59API and review the resulting usage regularly. Its low-cost, pay-as-you-go model access and referral rebate can make repeated development and production workloads easier to control. If the numbers work for your traffic, sign up for 59API and begin with a small, measured rollout rather than migrating everything at once.

Tarifs · Docs