Speed tiers

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.

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."}]}'

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."}'

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."}]}'

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)

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)

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 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. With an Anthropic BYOK key, 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.

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

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

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."}]
  }'

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."
  }'

With the OpenAI Python SDK, pass the same field:

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 instead and no tier is reported for it. The request log 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. 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), 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, 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 for retry guidance.

Get started

Build

Modalities

Manage

Fast

Request Fast

Fast prices and delivered speed

Fast errors and fallback

Ultrafast

Make a request

Which tier served the request

Routing

Pricing

With your own OpenAI key

Errors

​Fast

​Request Fast

​Fast prices and delivered speed

​Fast errors and fallback

​Ultrafast

​Make a request

​Which tier served the request

​Routing

​Pricing

​With your own OpenAI key

​Errors

Fast

Request Fast

Fast prices and delivered speed

Fast errors and fallback

Ultrafast

Make a request

Which tier served the request

Routing

Pricing

With your own OpenAI key

Errors