# Apertis Changelog: 2.2.131 — Price Updated

Canonical page: https://apertis.ai/changelog/2.2.131
Markdown mirror: https://apertis.ai/changelog/2.2.131.md
Version: 2.2.131
Title: Price Updated
Published: 2026-11-20
Category: fix

Cache reads on Claude 5.5 models were billed at twice their list rate; now each model's cache reads bill at its list rate, and a streamed chat completion your client leaves before the first byte is not billed.

## Details

We fixed three places where what we billed did not match what we list. Claude cache reads now bill at each model's list rate, a streamed chat completion that your client leaves before the first byte is not billed, and `gpt-image-2.6-flare` bills per token. The row for each request in Logs shows the token counts and the charge, so you can check the arithmetic.

## Cache reads bill at each Claude model's list rate

Cache reads on every Claude model were billed at 0.10x of the model's input price. Anthropic lists a lower rate for some models, so those reads cost more than the list says: 2x on Opus 5.5 and Sonnet 5.5, 4x on Fable 5.1 and 5.2. Each model now bills at its own list rate. Cache writes did not change.

![Terminal: the cache read rate of claude-opus-5.5 (0.05) and claude-opus-5 (0.1), a Logs row with 10,000 cache-read tokens and quota 5200, and a stream left before its first byte that writes no usage row](/changelog-media/2.2.131/cache-read-billing.jpg "demo:cache-read-billing")

| Model | Input, per 1M | Read rate, was | Read rate, now | Cache read, per 1M |
| --- | --- | --- | --- | --- |
| `claude-opus-5.5` | US$4 | 0.10x | 0.05x | US$0.20 |
| `claude-sonnet-5.5` | US$2 | 0.10x | 0.05x | US$0.10 |
| `claude-fable-5.1` | US$10 | 0.10x | 0.025x | US$0.25 |
| `claude-fable-5.2` | US$8 | 0.10x | 0.025x | US$0.20 |

Every other Claude model, `claude-opus-5` and `claude-fable-5` among them, reads at 0.10x as before. Cache writes stay at 1.25x of the input price for 5 minutes and 2x for 1 hour, on every Claude model. The id may carry the `apertis/` prefix or the `:web` suffix; the rate is the same.

The model list publishes the same rates, so you can check a model before you call it. `GET https://api.apertis.ai/api/v2/models/claude-opus-5.5` answers, under `data.model`:

```json
{
  "model_id": "claude-opus-5.5",
  "cache_rates": { "read": 0.05, "write_5m": 1.25, "write_1h": 2, "source": "provider" }
}
```

`cache_pricing.components.read.usd_per_1m_tokens` on the same object is `"0.200000"`, the figure in the last column above.

A request's row in Logs shows the token counts and the charge. This is a request on `claude-opus-5.5`, on an account with no group discount, with 300 fresh input tokens, 10,000 tokens read from cache and 100 output tokens (some fields left out):

| Logs field | Value |
| --- | --- |
| `model_name` | `claude-opus-5.5` |
| `fresh_input_tokens` | 300 |
| `cache_read_tokens` | 10000 |
| `completion_tokens` | 100 |
| `quota` | 5200 |

At US$4 per 1M input tokens, US$0.20 per 1M cache-read tokens and US$20 per 1M output tokens, that is 300 × 4 + 10,000 × 0.20 + 100 × 20 = 5,200 millionths of a dollar. `quota` is that figure, and 1 USD = 1,000,000 quota, so the request cost US$0.0052. At the old 0.10x, the cache read was US$0.40 per 1M tokens and the same request was 7,200, US$0.0072.

## What a stream that delivers nothing is billed

Each way a response can end with nothing delivered settles by its own rule. This is what each bills.

![A table of what is billed when a stream ends: a client that leaves before the first byte, a client that leaves after one, an upstream that ends with no output and no finish reason, and a model priced per request that returns an empty response](/changelog-media/2.2.131/stream-left-early.jpg)

| What happened | Billed |
| --- | --- |
| Your client disconnects from a streamed chat completion before any byte of the response body reached your connection. Headers alone do not count. | Nothing. The amount held for the request is returned and no usage row is written. |
| Your client disconnects after at least one byte of the response body. | The usage the model had reported by then. With no output tokens and no cache tokens reported, that is 0. A model priced per request is charged that price once. |
| A `/v1/messages` stream that a non-Anthropic-format upstream ends with no output and no finish reason. | Nothing. The amount held for the request is returned, as for a failed request. |
| A model priced per request returns an empty response, stream or not. | The per-request price is not charged. |

A stream that finishes normally with no output settles on the usage the model reported. With no cache tokens in that usage, the charge is 0. With cache tokens, the input (fresh and cached) is charged at its rates and the output at 0.

A byte counts whether the model sent it or we wrote it, such as the empty first chunk of a stream, and whether or not your client read it. On a subscription plan, a request that settles at 0 uses none of the plan's units.

## gpt-image-2.6-flare bills per token

`gpt-image-2.6-flare` was not billed at its listed per-token prices. It is now billed per token, from the usage the upstream reports for the call. For a generation, a text prompt in and an image out, the charge is the text-input tokens and the output tokens, each at its rate:

| Model | Text input, per 1M tokens | Output, per 1M tokens |
| --- | --- | --- |
| `gpt-image-2.6-flare` | US$5 | US$30 |

A response without usage is charged the model's per-call price. On an account with no group discount, a call with 100 text-input tokens and 1,000 output tokens on `gpt-image-2.6-flare` is (100 × 5 + 1,000 × 30) = 30,500 quota, US$0.0305. The row in Logs shows the two token counts, `prompt_tokens` and `completion_tokens`, and the quota charged.
