Cache Read Pricing for Claude Sonnet 5.5 Cut in Half: Measuring the Actual Impact of the Price Reduction

Introduction

On October 7, 2026, in the announcement of the release of Anthropic's Haiku 5.5, it was announced that the cache read price for Claude Sonnet 5.5 would be cut in half.

https://www.anthropic.com/claude-haiku-5-5

In this article, I confirm that the cache read price for Sonnet 5.5 on Amazon Bedrock has also been revised, run a chat using prompt caching with the Converse API, and present the measured results of its effect.

Pricing Revision

According to the announcement, cache read becomes 50% cheaper, going from $0.20 to $0.10 per million tokens.

Anthropic explains the effect of this price cut as follows.

Because cache reads make up a large share of models’ token consumption, this reduces the cost of Sonnet 5.5 on most agentic tasks by around 20%.

Bedrock Unit Prices

You can look up Bedrock unit prices with get-products of the Price List API. The service code is AmazonBedrockFoundationModels, and you filter the model by servicename.

aws pricing get-products --region us-east-1 --service-code AmazonBedrockFoundationModels \
  --filters 'Type=TERM_MATCH,Field=servicename,Value=Claude Sonnet 5.5 (Amazon Bedrock Edition)' \
            'Type=TERM_MATCH,Field=regionCode,Value=us-east-1'

The following table shows unit prices in us-east-1. The Sonnet 5.5 columns were taken from the result above, and the Sonnet 5 columns were taken from the Bulk API (index.json) of the Price List API. The unit is USD / 1M tokens.

Before the revision, the cache read price of Sonnet 5.5 was the same as that of the current Sonnet 5.

https://dev.classmethod.jp/articles/bedrock-claude-sonnet-5-5/

The Anthropic section of the AWS pricing page also has a note saying that, from October 7, the cache read price for Sonnet 5.5 has been reduced by 50% from before.

https://aws.amazon.com/bedrock/pricing/

Conditions for Using the Cache

According to the Bedrock documentation, there are three conditions for a cache hit.

• The same content must continue from the beginning. Checkpoints are processed in the order tools → system → messages, so changing an earlier part also invalidates the cache of later parts.
• The prefix up to the checkpoint must be at least the minimum number of tokens. It is 512 for Sonnet 5.5 and 1,024 for Sonnet 5.
• It must be reused within the TTL. The TTL is 5 minutes or 1 hour, and it is extended on every hit. Choosing 1 hour makes the cache write unit price higher.

Processing that fits these conditions includes chats that stack questions on a long fixed system prompt or document, and agents with long tools definitions.

Using the Cache with the Converse API

With the Converse API, you place a cachePoint at the end of the range you want to cache. This time there are two places: the end of system, and the end of the latest user message in each turn. The request for the second turn has the following structure.

{
  "modelId": "global.anthropic.claude-sonnet-5-5",
  "system": [
    {"text": "<固定ドキュメントを含む指示文>"},
    {"cachePoint": {"type": "default"}}
  ],
  "messages": [
    {"role": "user", "content": [{"text": "<1問目>"}]},
    {"role": "assistant", "content": [{"text": "<1問目の回答>"}]},
    {"role": "user", "content": [{"text": "<2問目>"}, {"cachePoint": {"type": "default"}}]}
  ],
  "inferenceConfig": {"maxTokens": 300}
}

The conditions this time are as follows.

• system: a fixed document of about 16,400 tokens, and an instruction to answer in Japanese in three sentences or fewer, based only on the document
• Questions: 20 short Japanese questions, sent in order while carrying over the conversation history
• Answers: maxTokens is set to 300 as the upper limit

Requests are sent with the AWS CLI.

aws bedrock-runtime converse --region us-east-1 \
  --cli-input-json file://<リクエスト>.json --output json

The usage for the second turn is as follows.

"usage": {
    "inputTokens": 4,
    "outputTokens": 300,
    "totalTokens": 16983,
    "cacheReadInputTokens": 16433,
    "cacheWriteInputTokens": 246,
    "cacheDetails": [
        {
            "ttl": "5m",
            "inputTokens": 246
        }
    ]
}

The 16,433 tokens written in the first turn are read as cache read in the second turn.

#!/usr/bin/env python3
"""使い方: chat-driver.py <model-id> <cache|nocache> <turns>"""
import json, subprocess, sys

model, mode, turns = sys.argv[1], sys.argv[2], int(sys.argv[3])
cache = mode == "cache"

questions = [l.strip() for l in open("questions.txt", encoding="utf-8") if l.strip()]
doc = open("document.txt", encoding="utf-8").read()
system_text = ("あなたは Amazon Bedrock のドキュメント担当アシスタントです。"
               "次のドキュメントだけを根拠に、日本語で、3文以内で簡潔に答えてください。\n\n"
               "<document>\n" + doc + "\n</document>")

history = []
for i in range(turns):
    user = {"role": "user", "content": [{"text": questions[i]}]}
    if cache:
        user["content"].append({"cachePoint": {"type": "default"}})
    system = [{"text": system_text}]
    if cache:
        system.append({"cachePoint": {"type": "default"}})
    req = {"modelId": model, "system": system, "messages": history + [user],
           "inferenceConfig": {"maxTokens": 300}}
    path = f"request-{i+1:02d}.json"
    json.dump(req, open(path, "w", encoding="utf-8"), ensure_ascii=False)

    proc = subprocess.run(
        ["aws", "bedrock-runtime", "converse", "--region", "us-east-1",
         "--cli-input-json", "file://" + path, "--output", "json"],
        capture_output=True, text=True, check=True)
    resp = json.loads(proc.stdout)

    # Return only the text blocks of the answer to the history (do not return reasoningContent)
    blocks = resp["output"]["message"]["content"]
    answer = "".join(b["text"] for b in blocks if "text" in b)
    u = resp["usage"]
    print(f"turn {i+1:02d} in={u['inputTokens']} out={u['outputTokens']} "
          f"cr={u.get('cacheReadInputTokens', 0)} cw={u.get('cacheWriteInputTokens', 0)} "
          f"stop={resp['stopReason']}", flush=True)

    history += [{"role": "user", "content": [{"text": questions[i]}]},
                {"role": "assistant", "content": [{"text": answer}]}]

Measured Chat Costs

Effect of the Price Cut

These are the costs when running the conversation on Sonnet 5.5 (Global). The unit prices are as in the table above. The cost unit is USD, and input is 4 tokens every turn. The cumulative reduction rate compares the cumulative cost before and after the revision up to that turn. The total row shows the values for all turns.

The cumulative reduction rate is half of the share of cache read in the pre-revision cost. Under these conditions, cache read accounted for about 40% of the pre-revision cost cumulatively through the 20th turn, and the reduction rate was 20.0%.

The calculation for the total is as follows.

改定前: 80 × 2.00 + 5,302 × 10.00 + 350,380 × 0.20 + 20,681 × 2.50 = 174,958.5（÷ 1,000,000 = $0.1750）
改定後: cache read が 350,380 × 0.10 = 35,038 になるので 139,920.5（$0.1399）
削減額: 350,380 × (0.20 − 0.10) ÷ 1,000,000 = $0.0350
削減率: 0.0350 ÷ 0.1750 = 20.0%

Cache read made up 40.1% of the pre-revision cost, and since it became half price, the reduction rate is 40.1% × 50% ≒ 20%. The reduction rate under the conditions measured this time was 20%.

With and Without Cache

I also ran the same system prompt and questions on Sonnet 5.5 without a cachePoint. The following table shows the cumulative cost (USD) up to each turn, calculated with the post-revision unit prices.

The reason the cached version is more expensive only in the first turn is that the same 16,433 tokens are processed at the cache write unit price (2.50) instead of the input unit price (2.00). The cumulative cost reverses at the second turn, and at the 20th turn the cached version was 82% cheaper cumulatively.

Cost Comparison with Sonnet 5

I ran the same system prompt and questions on Sonnet 5 as well, and lined them up against the Sonnet 5.5 measurements. Costs were calculated with Global unit prices.

The cache write in the first turn was 16,433 tokens for both, so switching from Sonnet 5 to 5.5 did not significantly increase input tokens.

If the output volume is comparable, the drop in the cache read unit price from 0.20 to 0.10 translates directly into savings.

Summary

The cache read unit price of Claude Sonnet 5.5 has been cut in half.

In processing like this one, where a long system prompt is sent repeatedly in a chat, cache read makes up a large share of the cost, so we confirmed that the price cut has a large effect.

If you are using Sonnet 5.5 without caching, I recommend reviewing whether there is room to make use of caching.