Prompt Caching in Claude API 2026: Save Up to 90% on Tokens

Prompt caching turns expensive repeated prompts into a near-free reuse — 90% off after the first call.

What is Prompt Caching?

The simplest way to think about it: imagine you have a 50-page legal document you want Claude to answer questions about. Without caching, every question sends those 50 pages again — paying full price each time. With caching, you send the 50 pages once and reuse them at 10% of the original cost for every later question.

How It Actually Works

Three steps happen behind the scenes:

1. First call: Claude reads your prompt. You mark a section with cache_control. Claude stores those tokens and charges a small write fee (25% more than normal input).
2. Subsequent calls within TTL: If your prompt's cached prefix matches exactly, Claude reads from cache at 10% of normal price.
3. After TTL expires: The next call re-writes the cache (small write fee again) and the cycle continues.

Two TTLs available: 5 minutes (default ephemeral) and 1 hour (opt-in, slightly higher write cost but lasts 12x longer).

Real Pricing Comparison

Example: A chatbot that sends a 10,000-token system prompt with every user message. The user sends 100 messages an hour. Using Claude Sonnet 4.6 (input $3 per million tokens):

Savings: 87% to 89%. The math compounds fast for any production AI app.

Code Example: Python & TypeScript

Python (with the official Anthropic SDK):

from anthropic import Anthropic
client = Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "You are an expert legal analyst. Document:\n\n" + long_document,
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[{"role": "user", "content": "Summarise the contract"}]
)

TypeScript:

import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  system: [
    {
      type: "text",
      text: "You are an expert legal analyst. Document:\n\n" + longDocument,
      cache_control: { type: "ephemeral" }
    }
  ],
  messages: [{ role: "user", content: "Summarise the contract" }]
});

That single cache_control field unlocks the 90% discount on every subsequent call within the 5-minute window.

When to Use Caching (and When Not)

Use caching when:

• You have a long system prompt repeated across calls (chatbots, agents)
• You are doing Q&A over the same document multiple times (RAG)
• You have few-shot examples used in every call
• You are running batch jobs that share context

Skip caching when:

• Your prompt is short (under 1024 tokens — minimum cacheable size)
• The context changes every single call
• You only make one or two API calls total

A well-cached production app sees 60% to 85% lower Claude API bills every month.

5 Best Practices

1. Cache the right block. Put cache_control on the longest stable part of your prompt — system instructions, large documents, few-shot examples.
2. Watch for prompt variations. Even a single character change breaks the cache match. Keep your cached prefix byte-for-byte stable.
3. Use 1-hour cache for batch jobs. If you run nightly batches, 1-hour cache saves more than 5-minute. The slightly higher write cost is worth it.
4. Monitor cache hit rate. The API response includes cache_read_input_tokens — if it stays high, your caching is working.
5. Combine with Batch API. Stack prompt caching with the Batch API discount for 95%+ total savings on async workloads.

For more on optimising Claude API costs, see our guides on How to Use Claude with Less Tokens and Claude Haiku vs Sonnet vs Opus.

Looking for the best information about prompt caching in Claude API? Quick takeaway: if you run any production Claude app, turn on prompt caching today. One cache_control field cuts your bill by 60% to 85% within the hour. There is no reason to skip this one.