> ## Documentation Index
> Fetch the complete documentation index at: https://impossibl.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Speed tiers

> Request Claude Fast or OpenAI Ultrafast, check delivered speed, and understand routing and billing.

Choose Fast for Claude Opus 5.5 or Ultrafast for supported OpenAI models. Each tier has its own prices and uses its provider's native API.

## Fast

Fast mode runs the same Claude Opus 5.5 model with up to 2.5× higher output tokens per second. It changes inference speed, not model capabilities. Time to first token may not improve by the same amount.

The gateway offers Fast only for `anthropic/claude-opus-5-5`, through Anthropic's own API. It skips Azure Foundry, including when Foundry normally serves the model first. Fast is not available through the gateway's Azure deployments or the Batch API.

### Request Fast

Use `service_tier: "fast"` on Chat Completions and Responses, or `speed: "fast"` on Messages. Streaming and tools work on all three endpoints. Send the control on every request in a tool loop.

<CodeGroup>
  ```bash Chat Completions theme={null}
  curl --fail-with-body https://api.impossibl.com/v1/chat/completions \
    -H "Authorization: Bearer $IMPOSSIBL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"model":"anthropic/claude-opus-5-5","service_tier":"fast","max_completion_tokens":256,"messages":[{"role":"user","content":"Summarize this ticket in one sentence."}]}'
  ```

  ```bash Responses theme={null}
  curl --fail-with-body https://api.impossibl.com/v1/responses \
    -H "Authorization: Bearer $IMPOSSIBL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"model":"anthropic/claude-opus-5-5","service_tier":"fast","max_output_tokens":256,"input":"Summarize this ticket in one sentence."}'
  ```

  ```bash Messages theme={null}
  curl --fail-with-body https://api.impossibl.com/v1/messages \
    -H "x-api-key: $IMPOSSIBL_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "Content-Type: application/json" \
    -d '{"model":"claude-opus-5-5","speed":"fast","max_tokens":256,"messages":[{"role":"user","content":"Summarize this ticket in one sentence."}]}'
  ```
</CodeGroup>

<CodeGroup>
  ```python OpenAI SDK theme={null}
  import os
  from openai import OpenAI

  client = OpenAI(base_url="https://api.impossibl.com/v1", api_key=os.environ["IMPOSSIBL_API_KEY"])
  # extra_body works even when the SDK's service_tier enum does not list fast.
  completion = client.chat.completions.create(
      model="anthropic/claude-opus-5-5",
      messages=[{"role": "user", "content": "Say hello."}],
      max_completion_tokens=256,
      extra_body={"service_tier": "fast"},
  )
  print(completion.service_tier)

  response = client.responses.create(
      model="anthropic/claude-opus-5-5", input="Say hello.",
      max_output_tokens=256, extra_body={"service_tier": "fast"},
  )
  print(response.service_tier)
  ```

  ```python Anthropic SDK theme={null}
  import os
  from anthropic import Anthropic

  client = Anthropic(base_url="https://api.impossibl.com", api_key=os.environ["IMPOSSIBL_API_KEY"])
  message = client.messages.create(
      model="claude-opus-5-5", max_tokens=256,
      messages=[{"role": "user", "content": "Say hello."}],
      extra_body={"speed": "fast"},
  )
  print(message.usage.speed)
  ```
</CodeGroup>

Chat also accepts the older `providerOptions.anthropic.speed` spelling. It goes through the same validation, routing and billing. If both spellings are set, they must agree. Speed controls in other provider buckets and per-fallback speed overrides return `400`.

On Messages, `speed: "standard"` is a no-op. `service_tier` belongs to Anthropic's separate Priority Tier contract; it does not enable Fast on that endpoint.

### Fast prices and delivered speed

Prices per million tokens, USD, passed through without margin:

| Model | Input | Output | Cache read | 5m cache write | 1h cache write |
| - | - | - | - | - | - |
| `anthropic/claude-opus-5-5` | \$8.00 | \$40.00 | \$0.40 | \$10.00 | \$16.00 |

These rates apply across the full context window. [Anthropic's cache multipliers](https://platform.claude.com/docs/en/about-claude/pricing#prompt-caching) apply to Fast input prices: Opus 5.5 reads cost 0.05×, 5m writes 1.25× and 1h writes 2×. Switching between Fast and standard invalidates the prompt cache; speeds do not share cached prefixes.

The balance check uses Fast rates. Promotional and negotiated standard prices do not apply to Fast. `GET /v1/models` lists standard prices only.

| Delivered value | Charge |
| - | - |
| `fast` | Fast rates |
| `standard` | Standard rates |
| Missing or unknown | Fast rates requested and quoted |

Chat Completions and Responses report the delivered speed in `service_tier`. In streams it arrives on terminal chunks or the completed/incomplete response event, with final usage. Messages reports `usage.speed` when a `speed` control was supplied and the provider reported `fast` or `standard`; in a stream, check `message_delta.usage.speed`.

The gateway never fills in delivered speed from the request. An absent Messages value stays absent; an unreported Chat or Responses tier is `null`. Requested, delivered and billed tiers appear in the [request log](/docs/request-logs).

With an Anthropic [BYOK key](/docs/byok), Fast uses your key and deducts 0 credits from both gateway ledgers. Your Anthropic account pays the provider's rates. Azure and Bedrock credentials do not serve Fast.

### Fast errors and fallback

* Unsupported model: `400`, naming `anthropic/claude-opus-5-5` as the supported model.
* An incompatible `x-impossibl-deployment` pin: `400`; a Foundry pin never silently overrides Fast.
* Insufficient balance at Fast rates: `402`.
* No native Anthropic route configured: `503`.
* Anthropic Fast capacity or rate limit (`429`/`529`): the gateway uses its existing upstream error mapping (`502` before streaming, an error event after streaming starts). It never retries at standard speed or on Foundry. See [errors](/docs/errors).

Your application can explicitly choose a standard-speed fallback. For example, using the Anthropic SDK and the gateway's current error mapping:

```python theme={null}
from anthropic import APIStatusError

params = dict(model="claude-opus-5-5", max_tokens=256,
              messages=[{"role": "user", "content": "Say hello."}])
try:
    message = client.with_options(max_retries=0).messages.create(
        **params, extra_body={"speed": "fast"})
except APIStatusError as error:
    # Choose which upstream failures your application should retry at standard speed.
    if error.status_code not in (429, 502, 529):
        raise
    message = client.messages.create(**params)
```

## Ultrafast

Ultrafast is OpenAI's low-latency processing tier for selected models. Ask for it with the top-level `service_tier` field on Chat Completions or Responses. It costs more than standard processing, so use it where response time matters and keep standard processing elsewhere.

| Model | Ultrafast |
| - | - |
| `openai/gpt-6.1-sol` | Supported |
| `openai/gpt-6-astra` | Supported |
| Every other model | `400` |

### Make a request

<CodeGroup>
  ```bash Chat Completions theme={null}
  curl --fail-with-body https://api.impossibl.com/v1/chat/completions \
    -H "Authorization: Bearer $IMPOSSIBL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "openai/gpt-6.1-sol",
      "service_tier": "ultrafast",
      "messages": [{"role": "user", "content": "Summarize this ticket in one sentence."}]
    }'
  ```

  ```bash Responses theme={null}
  curl --fail-with-body https://api.impossibl.com/v1/responses \
    -H "Authorization: Bearer $IMPOSSIBL_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "openai/gpt-6.1-sol",
      "service_tier": "ultrafast",
      "input": "Summarize this ticket in one sentence."
    }'
  ```
</CodeGroup>

With the OpenAI Python SDK, pass the same field:

```python theme={null}
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.impossibl.com/v1",
    api_key=os.environ["IMPOSSIBL_API_KEY"],
)

completion = client.chat.completions.create(
    model="openai/gpt-6.1-sol",
    service_tier="ultrafast",
    messages=[{"role": "user", "content": "Summarize this ticket in one sentence."}],
)
print(completion.service_tier)  # the tier that actually served it

response = client.responses.create(
    model="openai/gpt-6.1-sol",
    service_tier="ultrafast",
    input="Summarize this ticket in one sentence.",
)
print(response.service_tier)
```

`service_tier` accepts:

| Value | Meaning |
| - | - |
| omitted, `null`, `auto`, `default` | Standard processing at the model's normal rates. This is the same as sending no tier. |
| `ultrafast` | Ultrafast processing at Ultrafast rates, for the models above. |
| `fast` | Claude Fast, only for `anthropic/claude-opus-5-5` (see above). |
| `priority`, `flex`, anything else | `400 invalid_request_error`. These tiers are not offered. |

Use the top-level field. Older Chat Completions requests that set `providerOptions.openai.serviceTier` are treated as the same field, with the same accepted values; if both are set they must match.

### Which tier served the request

When a request sets `service_tier`, the response reports the tier OpenAI says it **actually** used, which can differ from the one you asked for:

| Response `service_tier` | What happened | Billed at |
| - | - | - |
| `"ultrafast"` | Served at Ultrafast. | Ultrafast rates |
| `"default"` | OpenAI served the request at the standard tier instead. | Standard rates |
| `null` | OpenAI did not report a tier. | Ultrafast rates |

The gateway never fills this field in from your request: `null` means the provider did not say. Because the gateway cannot confirm a downgrade in that case, the request is billed at the Ultrafast rate you asked for. Requests that do not set `service_tier` keep their usual response shape, without the field.

Where the field appears:

* **Chat Completions**: on the completion object; when streaming, on the final chunk with `finish_reason` and on the usage chunk (`stream_options.include_usage`). Earlier chunks do not carry it.
* **Responses**: on the response object; when streaming, on the `response.completed` or `response.incomplete` event. `response.created` and `response.in_progress` do not carry it.

The delivered tier is known only when generation finishes, so it arrives together with the final usage. If a stream fails after it has started, you receive the [stream error event](/docs/errors#a-stream-started-then-failed) instead and no tier is reported for it.

The [request log](/docs/request-logs) records the requested, delivered, and billed tier on the attempt that served the request.

### Routing

Ultrafast is served only through OpenAI's own API. Some models, such as `openai/gpt-6.1-sol`, are normally served by other hosts first; an Ultrafast request skips them. If OpenAI fails the request, the gateway does not retry it on another host or at the standard tier. You get an error, and you decide whether to resend without `service_tier`. See [routing and failover](/docs/routing).

Tool calling, streaming, reasoning controls and multi-turn tool results work as they do for standard requests. Send `service_tier` on each request in a tool loop; it is not remembered between requests.

### Pricing

Ultrafast rates are higher than standard rates: currently 6× each standard rate. Prices per million tokens, USD:

| Model | Input | Cached input | Cache write | Output |
| - | - | - | - | - |
| `openai/gpt-6.1-sol` | \$12.00 | \$0.60 | \$15.00 | \$60.00 |
| `openai/gpt-6.1-sol`, input over 272K tokens | \$24.00 | \$1.20 | \$30.00 | \$90.00 |
| `openai/gpt-6-astra` | \$60.00 | \$6.00 | \$75.00 | \$300.00 |
| `openai/gpt-6-astra`, input over 272K tokens | \$120.00 | \$12.00 | \$150.00 | \$450.00 |

As with standard long-context tiers (see [how request costs are calculated](/docs/billing#check-what-you-spent)), a request with more than 272,000 input tokens is billed entirely at the higher row, not only the tokens past the threshold. `GET /v1/models` lists standard rates; Fast and Ultrafast rates are not in the catalog listing.

* The balance check before generation uses Ultrafast rates. A balance that covers a standard request can return `402` for the same request at Ultrafast.
* Negotiated workspace rates and promotional prices apply to standard processing only. Ultrafast requests are billed at the rates above.
* `openai/gpt-6-astra` requires purchased credits, as for standard requests.

Latency depends on the prompt, output length and current provider load. Measure it on your own workload before relying on a particular speedup.

### With your own OpenAI key

If you added an OpenAI [BYOK credential](/docs/byok), Ultrafast requests use it and deduct 0 credits, as with any BYOK request. Your OpenAI organization must have access to Ultrafast for the model; if OpenAI refuses, you get its error and the request is not retried on the gateway's credentials. Azure, Azure Foundry and Bedrock credentials never serve Ultrafast requests.

### Errors

| Status | When |
| - | - |
| `400 invalid_request_error` | `service_tier` is not one of the accepted values; `service_tier` and `providerOptions.openai.serviceTier` disagree; a tier is set inside another `providerOptions` entry; or the model does not support Ultrafast (`code: unsupported_service_tier`). |
| `402 insufficient_quota` | The balance does not cover the estimated input at Ultrafast rates. |
| `502 upstream_error` | OpenAI refused or failed the request, for example when a BYOK organization lacks Ultrafast access. Nothing was retried at the standard tier. |
| `503 provider_not_configured` | No OpenAI route is available for the model, so Ultrafast cannot be served. |

See [error handling](/docs/errors) for retry guidance.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.