AWS Bedrock GPT-5.6 Prompt Caching Cost Guide

Quick answer

GPT-5.6 prompt caching on Amazon Bedrock is useful when a large prompt prefix stays identical across repeated Responses API calls. The documented billing multipliers are:

• uncached input: 1.00 × the model input rate;
• cache write: 1.25 × the uncached input rate;
• cache read: 0.10 × the uncached input rate, a 90% discount.

Use the live Bedrock pricing page for the base input rate. Do not calculate from an old launch price.

For a measurement period, a normalized input-cost estimate is:

(uncached_tokens × 1.00)
+ (cache_write_tokens × 1.25)
+ (cached_tokens × 0.10)

Compare that result with the same token volume billed as uncached input. Include output and other request costs separately.

Configure the client and provider boundary first with the Bedrock GPT-5.6 Responses API guide.

Current cache rules

Rule	GPT-5.6 on Bedrock
API	Responses on bedrock-mantle
Default mode	Implicit
Explicit boundary	prompt_cache_breakpoint on a supported content block
Stable routing key	prompt_cache_key
Minimum prefix per breakpoint	1,024 tokens
Maximum checkpoints	4 per request
TTL	At least 30 minutes; default 30m
Read evidence	usage.input_tokens_details.cached_tokens
Write evidence	usage.input_tokens_details.cache_write_tokens

The supported content blocks include input_text, input_image, and input_file. A request shorter than the minimum can still succeed while caching nothing.

Start with implicit mode

Implicit caching is on by default. Bedrock places an automatic breakpoint and attempts to reuse an eligible stable prefix without new request fields.

Structure the prompt so stable material comes first:

1. durable developer instructions;
2. stable tool definitions or reference material;
3. the changing question, event, or tool result last.

Use the same prompt_cache_key for related calls and log the usage fields. If hit rates and cost are already acceptable, explicit caching adds no automatic value.

Use explicit mode for a measured boundary

Explicit mode is useful when an agent loop has a known stable prefix and implicit placement does not produce reliable reuse.

response = client.responses.create(
    model="openai.gpt-5.6-terra",
    prompt_cache_key="support:policy-v3",
    input=[
        {
            "type": "message",
            "role": "developer",
            "content": [{
                "type": "input_text",
                "text": STABLE_POLICY,
                "prompt_cache_breakpoint": {"mode": "explicit"},
            }],
        },
        {
            "type": "message",
            "role": "user",
            "content": [{"type": "input_text", "text": user_question}],
        },
    ],
    extra_body={
        "prompt_cache_options": {"mode": "explicit", "ttl": "30m"}
    },
)

The first call should write an eligible prefix. A later call with the same key and byte-stable prefix can read it. Cache hits are not guaranteed on every request, so evaluate a series rather than one pair.

Verify the write-once, read-many pattern

Log these fields alongside request ID, model, Region, cache key version, latency, and outcome:

details = response.usage.input_tokens_details
print({
    "cached_tokens": details.cached_tokens,
    "cache_write_tokens": details.cache_write_tokens,
    "input_tokens": response.usage.input_tokens,
})

Interpret the evidence carefully:

• cache_write_tokens > 0, cached_tokens = 0: the request populated a cache;
• cached_tokens > 0, cache_write_tokens = 0: the request read an existing prefix;
• both zero: the prompt may be too short, unstable, ineligible, or uncached;
• cache_write_tokens = 0 by itself: not enough to claim a hit.

AWS states that cached_tokens is already included in input_tokens. Avoid adding it a second time in token dashboards.

A cost worksheet

Aggregate real traffic by cache-key version and workload. For each group, collect:

Metric	Why it matters
Total input tokens	Baseline volume
Cache-write tokens	Premium-priced setup work
Cached tokens	Discounted reuse
Uncached remainder	Full-rate changing content
Successful tasks	Prevents optimizing cheap failures
p50/p95 latency	Tests whether reuse improves responsiveness
Expired or changed prefixes	Explains repeated writes

Compare cost per successful task, not only the cached-token ratio. A stable prefix that contains irrelevant documents can show a high hit rate while reducing answer quality or increasing total input.

Common reasons caching misses

• timestamps, request IDs, user data, or changing tool order appear before the breakpoint;
• whitespace or serialization changes alter an otherwise equivalent prefix;
• the prefix contains fewer than 1,024 tokens;
• the cache key changes across related requests;
• a deployed policy version changes but the key version does not;
• the next call arrives after the TTL window;
• multiple checkpoints consume writes without creating useful reuse.

Keep secrets and user identifiers out of cache keys. Version the key when the stable prefix changes semantically, and document retention and tenant-isolation requirements.

Frequently asked questions

How is GPT-5.6 prompt caching billed on Amazon Bedrock?

AWS documents cache reads at a 90% discount from uncached input and cache writes at 1.25 × the uncached input rate. Use the live Bedrock pricing page for the underlying model rate.

What are the GPT-5.6 cache limits on Bedrock?

Each breakpoint needs at least 1,024 tokens, a request can use up to four checkpoints, and cached prefixes remain available for at least 30 minutes. The default TTL is 30m.

How do I verify a cache hit?

Inspect usage.input_tokens_details. A positive cached_tokens value is evidence of a read. A zero cache_write_tokens value alone is not evidence of a hit.

Official sources

• AWS: Introducing explicit prompt caching for OpenAI GPT-5.6 models
• Amazon Bedrock prompt caching documentation
• Amazon Bedrock pricing

Source check: August 4, 2026. Verify live pricing, cache limits, supported fields, and usage accounting before making a cost commitment.