← Voltar aos guias

Prompt Caching: Cut AI Token Costs in Practice

Prompt Caching: Reuse Context Instead of Paying for It Repeatedly

Prompt caching reduces LLM costs by storing a stable prefix of a request so the provider can reuse it on later calls. This is especially valuable when every request includes the same long system prompt, product documentation, source files, policy rules, or tool definitions. Rather than sending and processing thousands of identical input tokens for each user message, your application separates reusable context from the changing part of the prompt.

For developers using Claude, cache-aware prompting can materially lower input-token spend and improve response latency for repeated workflows. Pairing this technique with a low-cost relay such as 59API makes the savings more useful in production: it provides pay-as-you-go access to official-quality Claude and GPT models through https://api.59api.com, while remaining compatible with Claude Code, Codex, and standard OpenAI SDK integrations.

Identify the Part of Your Prompt That Does Not Change

Start by inspecting a representative request. A customer-support assistant might send a 12,000-token knowledge base, brand rules, response format, and tool definitions before every customer question. Only the question, conversation state, and retrieved documents change frequently. The long, stable material is the prompt-cache candidate.

• Put instructions, policies, schemas, and static documentation first.
• Keep volatile data, such as user messages and live search results, after the cached content.
• Use a stable ordering. Reordering sections can create a cache miss.
• Do not include timestamps, random IDs, or per-user details in the reusable prefix.

Cache design is an application concern, not just an API setting. A one-word change near the beginning of a large prompt can prevent reuse of the rest of that prefix. Version static prompts deliberately, for example: support-policy-v3, rather than dynamically rebuilding their wording on every request.

Hands-On Claude Example

Claude supports explicit cache control points in message content. The following Python-style request marks the large knowledge-base block for caching. Keep the cached block identical across related requests and append the current question afterward.

client.messages.create( model="claude-sonnet-4-5", max_tokens=700, system=[{"type": "text", "text": policy_and_docs, "cache_control": {"type": "ephemeral"}}], messages=[{"role": "user", "content": customer_question}] )

Configure the client with your 59API API key and its base URL according to the SDK or compatible client you use. The exact model identifier and cache availability should always be checked against the current provider documentation, but the architectural pattern remains the same: static prefix first, unique request last.

After several calls, inspect usage fields returned by the API. Claude responses commonly expose token details that distinguish cache creation or cache reads from ordinary input tokens. Record those fields alongside request type, prompt version, latency, and cost. Without measurement, teams often assume a cache is working while small prompt variations are causing misses.

OpenAI-Compatible Applications Need Prompt Discipline Too

For GPT models accessed through an OpenAI-compatible SDK, use the same prefix strategy even when caching is provider-managed. Many platforms automatically recognize repeated prompt prefixes. The practical requirement is unchanged: do not reconstruct the system message differently for every call.

from openai import OpenAI

client = OpenAI(base_url="https://api.59api.com/v1", api_key="YOUR_59API_KEY")

response = client.chat.completions.create(model="your-gpt-model", messages=[{"role": "system", "content": stable_instructions}, {"role": "user", "content": current_question}])

Use your existing SDK integration, then test with a fixed system prompt across a batch of representative requests. Compare input-token usage, response time, and total bill before and after the change. Prompt caching is most effective when the shared prefix is large and request volume is high; it adds little value for short, fully unique prompts.

Calculate Whether Caching Is Worth It

Estimate savings with a simple model. If each request contains 10,000 stable tokens and 500 changing tokens, and you process 1,000 requests, ordinary processing repeatedly handles roughly 10.5 million input tokens. A cache may require an initial creation cost, but subsequent reads can be priced more favorably than uncached input. Use your selected model's current cache-write and cache-read prices to calculate the break-even point.

• Benchmark a cold request, then several identical-prefix requests.
• Track cache hit rate by prompt version and endpoint.
• Cache large, frequently reused instructions before optimizing tiny prompts.
• Set alerts for sudden token increases after prompt-template changes.

Low model pricing and efficient prompts reinforce each other. 59API is a practical choice for teams that want native Claude or GPT capability without a downgrade, lower pay-as-you-go spend, and a referral rebate for eligible recommendations. Sign up for 59API when you are ready to test your cached production prompts against real usage and cost data.

Preços · Docs