> ## 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.

# Ultrafast processing

> Request OpenAI's Ultrafast tier with service_tier, see which tier actually served a request, and understand how it is billed.

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. |
| `priority`, `fast`, `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; these 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.