Prompt Caching Cost 2026: Discount Table + Savings Formula

By Per Million · Published October 23, 2026 · 19 min read

• Prompt Caching
• LLM API Pricing
• Claude
• OpenAI

Prompt caching cost is what you pay to reuse input tokens a provider has already processed. A cache read on current flagship models costs 5–10% of the normal input price, and some providers also charge a one-time cache write premium of 1.25x–2.5x. The discount alone won't tell you what you'll save. Your savings come from three numbers: how many tokens in each request are a repeated prefix, how often that prefix is still in cache (your hit rate), and how many requests you send. The formula and tables below turn those into dollars for OpenAI, Claude, Gemini and Amazon Bedrock (all prices as of October 2026; check the official pages).

Which option is right for you?

Start with the provider and caching mode that matches how you already work. You can switch later once you have real hit-rate numbers.

Here's the reasoning in one line each. OpenAI's older models are the safest place to start because a cache miss never costs extra. Claude's 0.05x read rate on the 5.5 models is one of the deepest discounts, but you pay 1.25x on every write. Gemini explicit caching locks in near-100% hit rates for one fixed document, and you pay for that by the hour.

What Is Prompt Caching Cost?

Prompt caching cost is the discounted rate for reused input tokens (a cache hit), plus any fee to store them (a cache write or hourly storage). Every provider caches by exact prefix match, so only the unchanged start of your prompt qualifies.

When you send a request, the model has to process every input token. With caching, the provider keeps the processed state of your prompt's prefix for a while. That prefix is usually tools, then the system prompt, then earlier messages. The next request that starts with the same tokens reads that state at a lower rate. Anthropic's docs list the hierarchy as tools → system → messages, and a change to tool definitions invalidates everything after it (Anthropic).

There are three line items you can be billed for:

1. Cache read (hit). These tokens are billed at a fraction of base input. Claude Sonnet 5.5 is $0.10 per million tokens against a $2 base (Anthropic pricing). GPT-5.6 Terra is $0.20 against $2 (OpenAI pricing). Gemini 3.8 Flash is $0.075 against $0.75 (Google).
2. Cache write. Anthropic charges 1.25x base for a 5-minute write and 2x for a 1-hour write. OpenAI's GPT-5.6-and-later models charge 1.25x for the 30-minute TTL and 2.5x for 12 hours. Older OpenAI models charge no write fee (OpenAI guide).
3. Storage. Only Gemini explicit caching bills by the hour: $0.50 per million tokens per hour on Gemini 3.8 Flash and $1.00 on Gemini 2.5 Flash (Google).

Output tokens are never cached, so caching does nothing for long answers. If output dominates your bill, see the per-model output prices in our LLM API pricing comparison.

Does Prompt Caching Reduce Cost? (With a Worked Formula)

Yes, prompt caching reduces cost once your hit rate clears a break-even point. That point is about 21% for 5-minute Claude writes and 0% for OpenAI models with no write fee. A low hit rate with write fees can cost more than not caching.

The formula

Use these variables (all prices per million tokens):

• N = requests per month
• P = cacheable prefix tokens per request, in millions (10,000 tokens = 0.01)
• h = cache hit rate, from 0 to 1
• B = base input price, R = cache read price, W = cache write price (equal to B if there's no write fee)
• S = storage price per million tokens per hour, T = hours the cache is kept (Gemini explicit only)

Prefix cost without caching = N × P × B
Prefix cost with caching    = N × P × [h × R + (1 − h) × W] + P × S × T
Monthly savings             = (cost without) − (cost with)
Break-even hit rate         = (W − B) / (W − R)

The (1 − h) × W term assumes every miss rewrites the prefix. That's how Anthropic and OpenAI's explicit-breakpoint models behave when a cache entry has expired.

Break-even hit rates by provider

The multipliers come from Anthropic and OpenAI. The Gemini ratios are worked out from list prices on Google's pricing page.

Worked example (illustrative numbers)

Say you run a support bot with a 10,000-token system prompt and help-center excerpt. Each call adds 300 user tokens and returns 400 output tokens, and you send 100,000 requests a month. The prefix is 1,000 million tokens a month. Assume a 90% hit rate on the prefix.

On Claude Sonnet 5.5 with 5-minute caching:

1. Without caching: 1,000 × $2 = $2,000 for the prefix.
2. With caching: 900 × $0.10 + 100 × $2.50 = $90 + $250 = $340.
3. User input (30M × $2 = $60) and output (40M × $10 = $400) stay the same.
4. The monthly total drops from $2,460 to $800, a 67% saving on the whole bill, even though the prefix alone fell 83%.

The gap between 83% and 67% is why the "up to 90%" headline doesn't match your invoice. Output isn't discounted, and misses still pay the write rate.

Now run the same workload at a 15% hit rate, which you might see with bursty traffic. The cost becomes 150 × $0.10 + 850 × $2.50 = $2,140, which is more than the $2,000 you'd pay without caching. That's the break-even table at work.

Steps to calculate your own savings

1. Log one day of real responses and add up the cache fields: cache_read_input_tokens and cache_creation_input_tokens (Anthropic), cached_tokens and cache_write_tokens (OpenAI), cached_content_token_count (Gemini), or cacheReadInputTokens and cacheWriteInputTokens (Bedrock).
2. Hit rate = read tokens ÷ (read + write tokens) for the cacheable part.
3. Plug in N, P, h and that model's prices from the comparison table below.
4. Compare your h with the break-even rate. If you're close to it, use the shorter TTL or a provider with no write fee.

If you'd rather script this, our LLM cost calculator in Python walks through building one, and you can add the formula above as an extra function.

Prompt Caching Cost in Claude (API) vs Claude Code

On the Claude API you choose what to cache and pay explicit write and read rates. Claude Code caches automatically. You see the effect through /usage, not on a per-request invoice, and subscribers don't pay per token at all.

Sources: Claude Code prompt caching, Claude Code costs.

According to Anthropic, enterprise Claude Code deployments average about $13 per developer per active day and $150–250 per developer per month, and 90% of users stay under $30 per active day (Claude Code costs). Most of that input is cache reads. The sample /usage output in the docs shows 940.0k cache-read tokens next to 50.0k cache-write tokens and only 1.2k uncached input.

How to check your cache hit rate in Claude Code

1. Run /usage in the session.
2. Find the Prompt cache (main) line, for example 14 requests · 91% of input tokens from cache · 2 misses.
3. If misses are high, look for the likely cause: text (v2.1.260+), such as tool definitions changed.
4. To confirm which TTL your writes used, run claude -p "hello" --output-format json and check ephemeral_1h_input_tokens and ephemeral_5m_input_tokens under usage.cache_creation.

Pitfalls and fixes

• Switching models mid-task. Each model has its own cache, so /model rereads the whole history uncached. Pick your model at the start of a session (docs).
• Coming back after a long break. The first message after the TTL runs out reprocesses everything. If you're on an API key and often step away, set promptCacheTtl to 1h. That doubles the write cost, so it only pays off when you'd otherwise miss more than half the time.
• A gateway that strips cache_control. Your whole history then bills as uncached input on every turn. Make sure your proxy forwards the markers unchanged.

If you're deciding between paying per token and a flat subscription for Claude Code, our Claude API vs Max plan break-even table works through that choice.

Anthropic Prompt Caching Pricing: Cache Write vs Cache Read Rates

Anthropic charges 1.25x base input for a 5-minute cache write and 2x for a 1-hour write. Cache reads cost 0.1x base on most models, 0.05x on Opus 5.5 and Sonnet 5.5, and 0.025x on Fable 5.1 and Mythos 5.1.

Prices are per million tokens, as of October 2026 (Anthropic prompt caching, Anthropic pricing; check the official page).

Rules that affect your bill:

• Minimum prefix. 512 tokens on the 5.5 models, Fable 5.1 and Mythos 5.1. 1,024 on Opus 4.8, Sonnet 5 and Sonnet 4.6. 4,096 on Opus 4.5–4.7 and Haiku 4.5. A shorter prefix isn't cached even if you mark it.
• Up to 4 breakpoints per request, each with a 20-block lookback.
• Rate limits. Anthropic says cache hits aren't deducted against your rate limit, which matters if you're throttled on input tokens per minute.
• Usage math. Total input = cache_read_input_tokens + cache_creation_input_tokens + input_tokens.

Steps: add caching to a Claude API call

1. For the simplest setup, pass cache_control={"type": "ephemeral"} at the top level of client.messages.create. Anthropic calls this automatic caching. It uses one of your four breakpoint slots.
2. For more control, put "cache_control": {"type": "ephemeral"} on the last system or tool block that stays identical across requests.
3. Add "ttl": "1h" only if requests are more than 5 minutes but less than an hour apart.
4. Check usage in the response. On the second identical call, cache_read_input_tokens should be above zero.

A common mistake is putting a timestamp or user ID in the system prompt. That changes the prefix on every call, so you pay 1.25x on every write and get no reads. Move anything that changes to the end of messages.

OpenAI Prompt Caching Cost: Rates and Eligibility Rules

OpenAI caches prompts of 1,024 tokens or more automatically. Cached reads cost 0.1x input on most models and 0.05x on GPT-6.1 Sol. GPT-5.6 and later charge a 1.25x write fee, while GPT-5.5 and earlier charge none.

Standard tier, per million tokens, as of October 2026 (OpenAI pricing; check the official page).

How retention works (OpenAI guide):

• GPT-5.6+: prompt_cache_options.ttl takes "30m" (the default) or "12h". You can mark explicit prompt_cache_breakpoint blocks and set prompt_cache_options.mode to "implicit" or "explicit". There's also an optional prewarm: true.
• GPT-5.5 / 5.5 Pro: "24h" via prompt_cache_retention.
• Earlier models: "in_memory" (5–10 minutes) or "24h". Zero Data Retention organizations default to in_memory. Everyone else defaults to 24h.

Pitfalls

• Rate limits work differently from Anthropic. OpenAI says cached input tokens still count toward your tokens-per-minute limit, so caching cuts your cost but doesn't raise your throughput.
• Moving to GPT-5.6 changes the math. A workload that saved money at any hit rate on GPT-5.5 now needs roughly 22% hits to break even. Watch cache_write_tokens against cached_tokens after you migrate.
• Rewriting history. If you edit earlier messages instead of appending new ones, or reorder tools, the prefix breaks. OpenAI suggests allowed_tools to change which tools can be called while the tool list stays the same.

To see your hit rate, open the Prompt Caching Dashboard that OpenAI's guide mentions. For full cost math on OpenAI models, see our OpenAI API pricing calculator.

Gemini Prompt Caching Cost: Explicit vs Implicit Caching

Gemini implicit caching is on by default and passes on the discount automatically with no storage fee. Explicit caching is a cache object you create, billed at the cached-token rate plus an hourly storage fee.

*Google labels Argon pricing as valid through November 30, 2026 and 3.8 Flash input pricing through December 31, 2026. The discount column is worked out from list prices. Paid tier, as of October 2026 (Gemini pricing; check the official page).

Key rules from Google's caching docs and the explicit caching page:

• Implicit caching works on Gemini 2.5 and newer. The minimum is 4,096 tokens for Gemini 4 Argon, 3.8/3.6 Flash and 3.1 Pro Preview, and 2,048 for 2.5 Flash/Pro.
• Explicit caching works only on Gemini 3 and 2.5 models through generateContent. It's not available for Gemini 4 Argon onward or in the Interactions API.
• An explicit cache defaults to a 1-hour TTL if you don't set one. Create it with client.caches.create() and a CreateCachedContentConfig.

Example: when explicit storage is worth it

Using the support-bot numbers from earlier (illustrative), a 10,000-token prefix is 0.01 million tokens. Keeping it as an explicit cache on Gemini 3.8 Flash around the clock costs 0.01 × $0.50 × 720 hours = $3.60 a month. Every request then reads it at $0.075 per million, so 100,000 requests cost $75 plus $3.60. Implicit caching at 90% hits would cost 900 × $0.075 + 100 × $0.75 = $142.50.

Explicit caching wins here because traffic is steady. Storage is charged per hour whether or not anyone sends a request, though. If you cache a 1-million-token document for 24 hours and query it twice, you pay $12 in storage on 3.8 Flash for two requests. For free-tier limits and more Gemini cost examples, see our Gemini API pricing and free tier guide.

Prompt Caching Pricing on AWS Bedrock

Bedrock bills cached tokens at each model's cache-read rate and writes at a rate that may be higher, with no separate storage line. Prices follow Anthropic's direct prices for Claude, but regional endpoints add a premium.

What the Bedrock prompt caching docs say:

AWS also documents that GPT-5.6+ writes on Bedrock bill at 1.25x uncached input, while GPT-5.5 and earlier have no write fee. For OpenAI models on Bedrock, cached tokens don't count against the input-tokens-per-minute quota, which is the opposite of OpenAI's direct API.

On price: AWS's pricing page notes that from October 7, 2026, cache read pricing for Claude Sonnet 5.5 dropped 50%. A public pricing-data update (models.dev PR #9053, a secondary source) lists Bedrock Sonnet 5.5 at $2 input, $2.50 cache write and $0.10 cache read on global endpoints. US/EU regional endpoints are $2.20, $2.75 and $0.11, a 10% premium. Check the AWS page for your region before you budget.

Steps: turn on caching in the Bedrock console

1. Open a chat playground in the Amazon Bedrock console.
2. Open the Configurations menu.
3. Turn on the Prompt caching toggle.
4. Run your prompts. Once the minimum is reached, Bedrock creates checkpoints for you. Choose View cache checkpoints to see them, and open the Caching metrics pop-up on a response to see read and write tokens.

In code, add {"cachePoint": {"type": "default"}} after static content in the Converse API. Add "ttl": "1h" only on models that support it.

Pitfalls

• Batch inference. Bedrock doesn't support prompt caching in its batch inference API. Our batch API discount table covers that tradeoff.
• Cross-region inference. AWS warns that it "may lead to increased cache writes" at times of high demand.
• Misreading inputTokens. With caching on, it counts only non-cached tokens. Total = inputTokens + cacheReadInputTokens + cacheWriteInputTokens.
• A ValidationException. You get this if you send ttl to a model that only supports 5 minutes.

Side-by-Side Comparison: Prompt Caching Cost Across OpenAI, Claude, Gemini, Bedrock

This table lists the numbers that decide real savings for each provider: write premium, read discount, minimum tokens and TTL, all as of October 2026.

Sources: Anthropic, OpenAI guide, OpenAI pricing, Gemini pricing, Bedrock docs.

To put the table in dollars, here's the earlier example (1,000 million prefix tokens a month, 90% hits, illustrative) on each model:

Sonnet 5.5 and GPT-6.1 Sol come out the same on prefix cost because their base, write and read prices match. If they're both on your shortlist, compare them on output quality and rate-limit behavior. Caching won't separate them.

Next steps

Start with today's logs. You don't need a new vendor to find out what caching saves you.

Do it yourself today:

1. Pull 24 hours of responses and work out your hit rate from the cache usage fields in the formula section.
2. Move anything that changes per request (timestamps, user names, retrieved snippets) after your last cache breakpoint, then measure again.
3. Compare your hit rate with the break-even table. If you're below about 25% on Claude or GPT-5.6+, use the shorter TTL or put that workload on a model with no write fee.

If you'd rather not manage it yourself:

• Claude Pro ($20/month, or $17/month billed annually) or Max ($100 or $200/month), as of October 2026 (claude.com/pricing; check the official page). These plans include Claude Code, which handles caching and uses the 1-hour TTL within plan usage. They suit individual developers whose main AI cost is coding. They don't suit product backends: your app's API traffic is still billed per token, and plan usage has session and weekly limits.
• Bedrock Prompt management lets you enable caching on stored prompts inside AWS, with pay-per-token billing and no extra fee for the feature. It suits teams already on AWS. It's a poor fit if you aren't on AWS, and regional endpoints cost 10% more than global ones, per the source above.

Related guides on Per Million:

• LLM API Pricing Comparison 2026: 5 Providers, Real Costs
• Batch API Discount 2026: OpenAI vs Claude vs Gemini Table
• Cheapest LLM API in 2026: Real Cost per 1M Tokens Table
• LLM Cost Calculator Python: Build One in 5 Steps (2026)

FAQ

What is prompt caching cost in Claude Code specifically?

Claude Code bills cache reads and writes at the same Claude API rates when you use an API key or a cloud provider, with a 5-minute TTL by default. On a Pro or Max subscription within plan usage, the main conversation gets a 1-hour TTL and usage counts against plan limits, not dollars. Run /usage to see the session's share of input served from cache.

What is prompt caching cost reduction in practice (realistic %, not marketing claims)?

It depends on your prefix size and hit rate. In this guide's illustrative support-bot example, a 90% hit rate cut the cached prefix by 83% but the whole Sonnet 5.5 bill by 67%, because output isn't discounted. At a 15% hit rate with 5-minute Claude writes, caching cost more than not caching.

Is prompt caching pricing on Bedrock the same as Anthropic's direct API?

On global endpoints the Sonnet 5.5 rates line up ($2 input, $2.50 write, $0.10 read), according to the pricing data cited above. US/EU regional endpoints carry a 10% premium. Bedrock also doesn't support caching in batch inference, so check the AWS page for your model and region.

How is Gemini prompt caching cost different from implicit caching?

Implicit caching is automatic, has no storage fee, and only discounts tokens when a hit happens to occur. Explicit caching guarantees the cached content is available for its TTL (1 hour by default), and you pay storage for every hour it exists, for example $0.50 per million tokens per hour on Gemini 3.8 Flash. Gemini 4 Argon supports implicit caching only.

Does AWS charge extra for prompt caching setup or storage?

AWS's documentation describes no setup or storage charge. You pay the cache-read rate for tokens read, the standard input rate for uncached tokens, and, depending on the model, a higher rate for tokens written. The Bedrock pricing page has the model-specific numbers.

Sources

• Anthropic: Prompt caching
• Anthropic: Pricing
• Claude Code: How Claude Code uses prompt caching
• Claude Code: Manage costs effectively
• Claude plans and pricing
• OpenAI: Prompt caching guide
• OpenAI: API pricing
• Google: Gemini API context caching
• Google: Gemini explicit caching (generateContent)
• Google: Gemini API pricing
• AWS: Prompt caching for faster model inference (Bedrock)
• AWS: Amazon Bedrock pricing
• models.dev PR #9053: Bedrock Claude Sonnet 5.5 pricing update (secondary source)

Spotted something out of date or wrong? Tell us at shigoto.ai.note@gmail.com. We check every guide against its official sources.