---
title: "Cache Read vs Cache Write Pricing: When Does Caching Pay Off?"
url: "https://goremy.ai/blog/articles/cache-read-price-vs-cache-creation"
author: Luis Chavez-Mattos
editor: Luis Chavez-Mattos
editor_title: Director, Product
published: "2026-11-21T03:40:19.426Z"
updated: "2026-11-21T03:40:19.426Z"
topic: AI Pricing & Costs
description: Cache reads cost a fraction of normal input tokens, while cache writes cost extra. See the rates, the math, and how many reads it takes to break even.
---

# Cache Read vs Cache Write Pricing: When Does Caching Pay Off?

> Cache reads cost a fraction of normal input tokens, while cache writes cost extra. See the rates, the math, and how many reads it takes to break even.

Edited by Luis Chavez-Mattos, Director, Product · Published 2026-11-21

## How is cache read priced compared to cache creation?

A cache read costs far less than normal input, and a cache write (creation) costs more. On Anthropic's Claude models, reading cached tokens runs 90% to 97.5% below the base input price, while a standard 5-minute write costs 1.25 times base input. A longer 1-hour write costs 2 times base input. On Claude Opus 5.5, for example, input is $4 per million tokens, a 5-minute write is $5, and a read is $0.20. Prices are as of October 2026, per Requesty's provider comparison.

## TL;DR

- **Reads are the cheap part.** Across the models in the comparison, a cache read costs 90% to 97.5% less than ordinary input tokens.
- **Writes carry a premium.** On Claude and newer OpenAI models, a short-lived write costs 1.25 times base input, and a long-lived write costs 2 to 2.5 times.
- **One read pays off a short write.** With a 5-minute write at 1.25x and a read at 0.025x to 0.10x, a single reuse already puts you ahead.
- **Long-lived writes need two reads.** The 1-hour and 12-hour options cost more up front, so you need at least two reads before you save money.
- **Caching only discounts the repeated part.** Output tokens and any new text in each request are billed at normal rates.
- **Unused caches cost you.** If nothing reads the cache before it expires, you paid a premium for nothing.

## What are cache writes and cache reads?

Many AI tasks send the same large block of text over and over: a company policy document, a long set of instructions, a product catalog, or a long conversation history. Prompt caching lets the provider store the processed version of that repeated block (the "prefix") so it does not have to be reprocessed every time.

Two events get billed differently:

- **Cache write (creation):** the first time the prefix is processed and stored. You pay a price per token for storing it.
- **Cache read (hit):** every later request that starts with the identical prefix and reuses the stored copy. You pay a much lower price.

Everything else in the request is billed as usual. The new question you add after the prefix is ordinary input, and the model's answer is ordinary output.

## What do the actual rates look like?

Requesty's October 2026 comparison lists direct API prices in US dollars per million text tokens. Where two write prices appear, the first is the shorter lifetime and the second the longer.

| Model | Input | Cache write | Read | Read discount |
| --- | --- | --- | --- | --- |
| Claude Fable 5.1 | $10 | $12.50 / $20 | $0.25 | 97.5% |
| Claude Opus 5.5 | $4 | $5 / $8 | $0.20 | 95% |
| Claude Sonnet 5.5 | $2 | $2.50 / $4 | $0.10 | 95% |
| Claude Haiku 5.5 | $0.10 | $0.125 / $0.20 | $0.01 | 90% |
| OpenAI GPT-6.1 Sol | $2 | $2.50 / $5 | $0.10 | 95% |
| OpenAI GPT-6.1 Terra | $1 | $1.25 / $2.50 | $0.05 | 95% |
| OpenAI GPT-6 Luna | $0.10 | $0.125 / $0.25 | $0.01 | 90% |
| OpenAI GPT-5.5 | $5 | Same as input | $0.50 | 90% |

Some details matter when you read this table:

- Claude's lifetimes are 5 minutes and 1 hour, and you opt in to caching. The newer OpenAI models offer 30 minutes (the default) and 12 hours (on the Responses API), and caching can be implicit or explicit.
- The write column is the total price for written tokens. It is not a surcharge on top of ordinary input.
- GPT-5.5 has no separate write premium. Caching is automatic, with retention of up to 24 hours.
- OpenAI rows use short-context rates, and higher context tiers cost more. These figures are also before gateway fees, taxes, batch discounts and regional premiums.
- Google's explicit Gemini caches add storage charges, so the math there has an extra term.

The pattern is consistent. Short writes cost 1.25 times input, long writes cost 2 to 2.5 times input, and reads cost 0.025 to 0.10 times input.

## How many reads does it take before caching saves money?

Break-even is simple. Your extra cost is the write premium (write price minus normal input price). Your saving on each read is the normal input price minus the read price. Divide the first by the second.

**Short write on Claude Opus 5.5:**

- Premium: $5 − $4 = $1 per million tokens.
- Saving per read: $4 − $0.20 = $3.80.
- Break-even: $1 ÷ $3.80 = about 0.26 reads.

That means the first read already puts you ahead. The same holds for every 1.25x write in the table: the premium is 0.25 times input, and each read saves at least 0.9 times input.

**Long write on Claude Opus 5.5:**

- Premium: $8 − $4 = $4.
- Saving per read: $3.80.
- Break-even: $4 ÷ $3.80 = about 1.05 reads.

So one read is not enough. You lose a little after one read and win after two. The same is true for the 12-hour OpenAI writes, where the premium is 1.5 times input against a saving of about 0.95 times input per read.

| Write type | Typical premium over input | Reads needed to break even |
| --- | --- | --- |
| Short (5 or 30 minutes) | 25% | 1 |
| Long (1 hour) | 100% | 2 |
| Long (12 hours, OpenAI) | 150% | 2 |
| No write premium (GPT-5.5) | 0% | Any read saves money |

## What does a worked example look like?

Say a support team sends a 50,000-token policy manual with every question to Claude Sonnet 5.5. That is 0.05 million tokens. We will ignore the short question and the answer, which cost the same either way.

- No caching: 0.05 × $2 = **$0.10 per request**.
- 5-minute write: 0.05 × $2.50 = **$0.125** once.
- Cache read: 0.05 × $0.10 = **$0.005 per request**.

Cumulative cost of the manual portion:

| Requests | No cache | With 5-minute cache |
| --- | --- | --- |
| 1 | $0.100 | $0.125 |
| 2 | $0.200 | $0.130 |
| 10 | $1.00 | $0.170 |
| 100 | $10.00 | $0.620 |

The first request costs 25% more. The second already costs less in total. By 100 requests, you pay about 6% of the uncached price.

Now the 1-hour write at $4 per million tokens, which costs $0.20 for this prefix. After the write and one read, you have spent $0.205 against $0.20 uncached, so you are slightly behind. After two reads you have spent $0.21 against $0.30. The longer lifetime only makes sense if you expect many reads, or reads spread out over more than a few minutes.

## When does caching cost more than it saves?

Caching backfires in a few predictable situations.

- **Reads never happen.** A write with no reads is pure premium. If each request is a one-off, you pay 25% more for nothing.
- **The cache expires between requests.** If your requests come every 10 minutes and the cache lasts 5, every request is a new write. You pay the premium each time and never get the discount.
- **The prefix keeps changing.** A cache hit needs an identical prefix. A timestamp or user name near the top of the text breaks the match, so every request becomes a write. Put stable content first and changing content last.
- **The cached part is small.** The discount only applies to the repeated portion. If most of your cost is output tokens, caching moves the total very little.

One developer on DEV Community described a prompt caching change that made their bill go up. A commenter pointed to the 25% surcharge on writes as the thing that adds up quickly when the cache is not reused. That matches the math above.

## How should you decide which write lifetime to use?

Look at your traffic, not the price list.

1. **Estimate how often the same prefix is reused.** A busy tool with requests every few seconds is a good fit for the short write.
2. **Check the gaps.** If gaps between requests regularly exceed the short lifetime, the cache will expire and you will rewrite it. A longer lifetime may be cheaper despite its higher write price.
3. **Count expected reads per write.** Under two reads, stay with the short option or skip caching. Over two, the long option starts to pay off.
4. **Measure cached tokens in your usage data.** Providers report how many tokens were served from cache. If the number is near zero, your prefix is not matching.
5. **Compare cost per finished task,** not just per-token rates. Read discounts alone do not predict the whole bill.

## What does this mean for you?

If you only use a chat app, you do not pick these settings. The provider handles them. But if you manage a team that builds or buys AI tools, this math explains the bill.

- **Managers and budget owners:** ask whoever runs the tool for the cache hit rate and the write-to-read ratio. A high number of writes relative to reads is a warning sign.
- **Analysts and operations staff running repeated tasks:** if you send the same document or instructions again and again, structure the request so the fixed text comes first and your question comes last.
- **Anyone comparing vendors:** look at write price, read price, lifetime and output price together. A cheap read rate with an expensive write can still lose on spiky traffic.

## Can you build your own caching cost calculator?

The arithmetic here fits in a small tool, and a team could make one that fits its own usage. With [Remy](https://goremy.ai), you can describe an internal app in plain English, such as a form where someone enters the model's input, write and read prices, the prefix size and the expected requests per hour. The app then shows cumulative cost with and without caching and flags the break-even point. Remy builds and deploys it as a full-stack web app. AI tokens in Remy are billed at cost, which makes this kind of cost tracking worth doing.

## Frequently Asked Questions

### Is a cache read always cheaper than normal input?

In the Requesty comparison, yes. Every model listed charges a read price 90% to 97.5% below its normal input price. The savings only apply to the tokens served from the cache, not to new text or the model's output.

### Is cache creation always more expensive than normal input?

Not always. Claude and the newer OpenAI models charge a premium for writes, starting at 1.25 times input. GPT-5.5 shows no separate write premium, so its writes cost the same as ordinary input. Google's explicit Gemini caches add storage charges instead.

### What is the minimum number of reads to make caching worthwhile?

For a short-lived write at 1.25 times input, one read is enough. For 1-hour or 12-hour writes, you need at least two reads. If you cannot expect that many reads before the cache expires, caching will likely cost you more.

### Do cached tokens also reduce output costs?

No. Prompt caching discounts the repeated input prefix only. The model still generates a fresh answer, and output tokens are billed at the normal output rate. If you want to skip the model call entirely, a response cache is a different tool that works where replaying an old answer is safe.

### Do these prices stay the same?

No. The figures here are direct provider API prices as of October 2026 and exclude gateway fees, taxes, batch discounts and regional premiums. Check the provider's current pricing page before you plan a budget.
