> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aihubmix.com/llms.txt
> Use this file to discover all available pages before exploring further.
# GPT-5.6 Is Live: Prompt Caching Billing Changes Explained
> July 2026: GPT-5.6 gpt-5.6-sol / terra / luna on AIHubMix — 1.05M context, 1.25x cache writes, prompt_cache_key, explicit breakpoints, vs Claude caching.
OpenAI officially released the GPT-5.6 family on July 9, 2026. AIHubMix has completed integration of all three tiers: `gpt-5.6-sol`, `gpt-5.6-terra`, and `gpt-5.6-luna` are now available through Chat Completions and Responses. The release also changes the prompt caching mechanism and its billing — cache writes are now billed separately. This post covers the positioning of the three tiers and walks through the caching changes point by point.
## What changes with the three GPT-5.6 tiers
GPT-5.6 revises the naming scheme: the number denotes the model generation, while Sol, Terra, and Luna are capability tiers that can evolve independently. Per the official definitions — Sol is the flagship model, Terra is a lower-priced tier with performance comparable to GPT-5.5, and Luna is the fastest, lowest-priced tier.
| | gpt-5.6-sol | gpt-5.6-terra | gpt-5.6-luna |
| :------------------------------------------ | :------------------------------------------- | :----------------------------- | :--------------------------- |
| Official positioning | Flagship model for complex professional work | Balanced intelligence and cost | For cost-sensitive workloads |
| Context window | 1,050,000 | 1,050,000 | 1,050,000 |
| Max output | 128,000 | 128,000 | 128,000 |
| Knowledge cutoff | 2026-02-16 | 2026-02-16 | 2026-02-16 |
| Rough equivalent in the previous generation | No-suffix tier | mini tier | nano tier |
On capabilities, the official position: Sol achieves state-of-the-art results on coding, knowledge work, cybersecurity, and science tasks, is described by OpenAI as its best coding model to date, and sets new records on Terminal-Bench 2.1 and DeepSWE; Terra matches GPT-5.5 performance at half the price. The family adds a max reasoning level, and the Responses API gains Programmatic Tool Calling and multi-agent (Beta) capabilities.
## The caching mechanism upgrade, explained
Before GPT-5.6, prompt caching on GPT models was fully automatic: prefixes of 1,024 tokens or more were cached automatically, developers had no control over what was cached or for how long, and caches were cleared after 5–10 minutes of inactivity. OpenAI summarizes the GPT-5.6 changes as "more predictable prompt caching", with three concrete points:
1. **Retention moves from "as short as 5 minutes" to "at least 30 minutes"**. `prompt_cache_options.ttl` currently only supports `"30m"`; that is a guaranteed minimum, and actual retention may be longer.
2. **Explicit cache breakpoints are new**. Setting `prompt_cache_breakpoint` on a content block pins the cache boundary at the end of stable content, so changes after the breakpoint do not invalidate the cached prefix before it; with `prompt_cache_options.mode` set to `"explicit"`, only manual breakpoints are used.
3. **`prompt_cache_key` moves from an optimization to an official requirement**. Starting with GPT-5.6, the parameter should be set to enable more reliable cache matching; OpenAI recommends keeping traffic per key to roughly 15 requests per minute.
## How to evaluate the 1.25x cache write billing
Starting with GPT-5.6, cache writes are billed at 1.25x the base input rate and cache reads at 0.1x; on earlier models, cache writes have no additional fee. The official wording (from the [GPT-5.6 announcement](https://openai.com/index/gpt-5-6/)): "For GPT-5.6 and later models, cache writes are billed at 1.25x the model's uncached input rate, while cache reads continue to receive the 90% cached-input discount."
The break-even math follows directly from the official rates: writing a prefix costs 0.25x the input rate more than not caching, and every subsequent hit saves 0.9x the input rate — **a prefix reused even once produces a net saving**, and the more reuse, the larger the saving.
* **Workloads that clearly benefit**: agent workflows with long system prompts, RAG that repeatedly includes long reference material, applications carrying large tool definitions, and multi-turn conversations that only append messages. These workloads have high prefix reuse, so the 0.1x read rate dominates.
* **Workloads to watch**: one-off long requests whose prefix is never reused. Automatic caching is on by default, so these requests incur an unrecoverable 1.25x write fee; setting `prompt_cache_options.mode` to `"explicit"` without setting any breakpoints makes the request skip the cache entirely and incur no write fee.
## Comparison: prompt caching on GPT-5.6 and Claude
GPT-5.6's caching design converges with Claude's `cache_control` on several dimensions, with the core difference in default behavior: GPT caches automatically with no parameters required, while Claude requires caching to be enabled in the request — either the top-level `cache_control` field (automatic breakpoint) or content-block-level explicit breakpoints.
| Dimension | GPT-5.6 family | Claude family (all active models) |
| :----------------------- | :----------------------------------------------- | :----------------------------------------------------------------------------------------------------------- |
| Activation | Automatic caching, explicit breakpoints optional | Must be enabled: top-level `cache_control` automatic breakpoint, or content-block-level explicit breakpoints |
| Breakpoint parameter | `prompt_cache_breakpoint` (content-block level) | `cache_control` (top level or content-block level) |
| Breakpoint limit | At most 4 new cache writes per request | At most 4 breakpoints |
| Cache retention | At least 30 minutes | 5 minutes by default (refreshed at no cost on every hit), optional 1 hour |
| Cache write billing | 1.25x input rate | 1.25x for the 5-minute tier, 2x for the 1-hour tier |
| Cache read billing | 0.1x input rate | 0.1x input rate |
| Minimum cacheable length | 1,024 tokens | 512–4,096 tokens depending on the model |
| Hit requirement | Byte-for-byte identical before the breakpoint | Byte-for-byte identical before the breakpoint |
The Claude column reflects the rules shared by all active Claude models: 1.25x writes for the 5-minute tier, 2x for the 1-hour tier, and 0.1x reads apply uniformly across the lineup ([Anthropic prompt caching documentation](https://platform.claude.com/docs/en/docs/build-with-claude/prompt-caching)), with per-model differences limited to the minimum cacheable length; the GPT-5.6 column comes from the [OpenAI prompt caching guide](https://developers.openai.com/api/docs/guides/prompt-caching).
The breakpoint limits, write rates (for the corresponding tiers), and read rates match exactly across the two providers; in practical terms, the same "static content first, changing content last" prompt structuring strategy carries over between them. Migration cost is concentrated in parameter syntax: GPT uses `prompt_cache_breakpoint` + `prompt_cache_key`, Claude uses `cache_control`.
## The same caching pattern in both protocols
For the same "cache a static long instruction" scenario, the minimal implementations in the two protocols follow. The examples use `gpt-5.6-sol` and `claude-opus-4-8` — both share the same base input price (\$5/M), so the effective per-token prices derived from cache writes (1.25x) and reads (0.1x) are also identical; only the syntax differs.
The GPT protocol sets `prompt_cache_key` at the top level (long prefixes are cached automatically, no breakpoint marker needed); the Claude protocol sets `cache_control` at the top level to enable automatic caching, switching to content-block-level breakpoints when precise control over the cache boundary is needed:
```shell GPT-5.6 (Chat Completions) theme={null}
curl https://aihubmix.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AIHUBMIX_API_KEY" \
-d '{
"model": "gpt-5.6-sol",
"prompt_cache_key": "my-app-report-v1",
"messages": [
{
"role": "system",
"content": "[Static long instructions, >=1024 tokens]"
},
{
"role": "user",
"content": "Summarize the key figures."
}
]
}'
```
```shell Claude (Messages) theme={null}
curl https://aihubmix.com/v1/messages \
-H "Content-Type: application/json" \
-H "x-api-key: $AIHUBMIX_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-d '{
"model": "claude-opus-4-8",
"max_tokens": 1024,
"cache_control": {"type": "ephemeral"},
"system": "[Static long instructions, >=1024 tokens]",
"messages": [
{
"role": "user",
"content": "Summarize the key figures."
}
]
}'
```
Comparing the two requests, the differences come down to: the endpoint (`/v1/chat/completions` vs `/v1/messages`), the auth headers (`Authorization: Bearer` vs `x-api-key` + `anthropic-version`), the caching parameter (top-level `prompt_cache_key` vs top-level `cache_control`), and Claude requiring an explicit `max_tokens`. Both requests were verified against aihubmix.com (2026-07-10): `gpt-5.6-sol` returned `cached_tokens: 2816` on the second call; `claude-opus-4-8` returned `cache_creation_input_tokens: 3632` on the first call and `cache_read_input_tokens: 3632` on the second.
Beyond the request format, three mechanism-level differences remain:
1. **Activation**: GPT caches automatically even without any caching parameters, with `prompt_cache_key` improving hit reliability; Claude requires a declaration — a content-block-level `cache_control` breakpoint, or the top-level `cache_control` automatic mode.
2. **Usage fields**: GPT reports cache reads in `prompt_tokens_details.cached_tokens`; Claude reports writes and reads separately as `cache_creation_input_tokens` and `cache_read_input_tokens`, making it easy to verify writes and hits independently.
3. **Lifetime control**: GPT-5.6's `ttl` currently only supports `"30m"`; Claude defaults to 5 minutes (refreshed at no cost on every hit), with an optional `"ttl": "1h"` (writes billed at 2x).
### What to change when swapping models across protocols
The AIHubMix gateway supports cross-protocol calls: the OpenAI-compatible endpoint can call Claude models (`cache_control` goes directly into OpenAI-format message content blocks; see [Prompt Caching practices](/en/practices/prompt-caching)), and the Claude-compatible `/v1/messages` endpoint can call GPT-5.6 (verified working). When swapping models, check three things:
* Change `model` to the target model ID;
* Switch the caching parameter syntax: `prompt_cache_key` / explicit breakpoints correspond to Claude's `cache_control`;
* Switch the usage field names: `cached_tokens` corresponds to Claude's `cache_read_input_tokens`.
Recommended paths for prompt caching: GPT models through Chat Completions (the cache-hit path verified in this post); Claude models work through either protocol.
## Comparison: GPT-5.6 vs earlier GPT caching
| Dimension | Before GPT-5.6 | GPT-5.6 and later |
| :------------------------- | :----------------------------------------------------- | :------------------------------------------------------------------------ |
| Cache writes | No additional fee | 1.25x input rate |
| Cache retention | Cleared after 5–10 minutes of inactivity, up to 1 hour | At least 30 minutes |
| Cache control | None | Explicit breakpoints, explicit mode, `prompt_cache_key` reliable matching |
| 24-hour extended retention | `prompt_cache_retention` on some models | Replaced by `prompt_cache_options.ttl` (currently 30m only) |
The changes point in one direction: earlier-generation caching was free of write fees but uncontrollable, with uncertain retention; GPT-5.6 charges for writes while providing a guaranteed retention floor and precise cache controls. By the rates, a prefix reused more than once on average saves more than the added write cost; the 30-minute retention floor and controllable breakpoints make reaching that reuse rate more predictable.
## Getting started on AIHubMix
All three tiers are live, with model IDs `gpt-5.6-sol`, `gpt-5.6-terra`, and `gpt-5.6-luna`. Caching requires no extra configuration; consecutive requests with the same long prefix hit the cache:
```py Python theme={null}
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["AIHUBMIX_API_KEY"],
base_url="https://aihubmix.com/v1",
)
long_context = "You are a meticulous assistant for analyzing quarterly financial reports... [Static long instructions, >=1024 tokens]"
for i in range(2):
completion = client.chat.completions.create(
model="gpt-5.6-sol",
prompt_cache_key="my-app-report-assistant-v1",
messages=[
{"role": "system", "content": long_context},
{"role": "user", "content": "Summarize the key figures in one sentence."},
],
)
print(completion.usage.prompt_tokens_details)
```
A `usage.prompt_tokens_details.cached_tokens` value greater than 0 on the second call indicates a hit (measured example: `cached_tokens: 2816`). For parameter details, billing specifics, and hit troubleshooting, see the [GPT Prompt Caching](/en/api/GPT-Cache) documentation.
## FAQ
### Which APIs can call GPT-5.6 on AIHubMix?
Chat Completions (`/v1/chat/completions`), Responses (`/v1/responses`), and the Claude-compatible Messages API (`/v1/messages`) can all call the models, and all three tiers are live. For prompt caching, Chat Completions is currently the recommended path.
### If my client changes nothing, what changes in billing after upgrading to GPT-5.6?
Prompt caching applies automatically by default: requests whose prefix reaches 1,024 tokens incur a cache write item billed at 1.25x the input rate, and reused prefixes are billed at the 0.1x read rate. Applications with high prefix reuse usually see lower total costs; one-off long requests that never reuse a prefix can disable caching with explicit mode.
### I have used Claude prompt caching — what do I change to migrate to GPT-5.6?
The prompt structuring strategy stays the same: static content first, changing content last. The parameters change from `cache_control` to `prompt_cache_breakpoint`, plus `prompt_cache_key`; retention changes from the 5-minute/1-hour tiers to a 30-minute guaranteed floor.
### How do I choose among the three GPT-5.6 tiers?
Per the official positioning: pick Sol for complex professional work and coding tasks; pick Terra for everyday workloads (GPT-5.5-level performance at half the price); pick Luna for cost-sensitive, high-volume scenarios. All three tiers share the same context window and max output, so you can route by task complexity.
## Official references
Model specifications, caching mechanisms, and billing rates in this post come from these official sources:
* [GPT-5.6 announcement](https://openai.com/index/gpt-5-6/) (OpenAI, 2026-07-09)
* [OpenAI prompt caching guide](https://developers.openai.com/api/docs/guides/prompt-caching)
* [OpenAI Pricing](https://developers.openai.com/api/docs/pricing)
* [Anthropic prompt caching documentation](https://platform.claude.com/docs/en/docs/build-with-claude/prompt-caching)
Related documentation on this site: [GPT Prompt Caching](/en/api/GPT-Cache) · [Claude Prompt Caching](/en/api/Claude-Cache) · [Prompt Caching practices](/en/practices/prompt-caching)
***
Visit the [model gallery](https://aihubmix.com/models) for GPT-5.6 pricing, or explore more integration options in the [documentation center](https://docs.aihubmix.com).
***
Last updated: 2026-07-10