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

# Service Tiers

> Trade cost against latency per request with flex and priority processing

## Overview

Service tiers let you choose how a request is processed. `flex` trades slower, queue-based processing for a lower price. `priority` trades a higher price for lower latency. Requests without a tier run at the standard tier, exactly as before.

Set the tier with the `service_tier` request parameter:

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.concentrate.ai/v1/responses \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "openai/gpt-5.6-luna",
      "input": "Summarize this document...",
      "service_tier": "flex"
    }'
  ```

  ```python Python theme={null}
  import requests

  response = requests.post(
      "https://api.concentrate.ai/v1/responses",
      headers={
          "Authorization": "Bearer YOUR_API_KEY",
          "Content-Type": "application/json"
      },
      json={
          "model": "openai/gpt-5.6-luna",
          "input": "Summarize this document...",
          "service_tier": "flex"
      }
  )

  # The tier the request was billed at
  print(response.json()["service_tier"])
  ```

  ```typescript TypeScript theme={null}
  const response = await fetch("https://api.concentrate.ai/v1/responses", {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "openai/gpt-5.6-luna",
      input: "Summarize this document...",
      service_tier: "flex"
    })
  });

  const data = await response.json();
  // The tier the request was billed at
  console.log(data.service_tier);
  ```
</CodeGroup>

The response reports the tier the request was actually served and billed at:

```json theme={null}
{
  "id": "resp_abc123",
  "status": "completed",
  "service_tier": "flex",
  "usage": { "input_tokens": 1204, "output_tokens": 96, "total_tokens": 1300 }
}
```

## Tier values

<ParamField body="service_tier" type="string" default="auto">
  One of `auto`, `default`, `flex`, `scale`, `priority`, `fast`, or `ultrafast`.
</ParamField>

| Value                | Effect                                                                                                                 |
| -------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| `auto`, `default`    | Standard processing and standard pricing.                                                                              |
| `flex`               | Lower price, higher latency. Requests may queue before processing starts.                                              |
| `priority`           | Lower latency, higher price.                                                                                           |
| `fast`               | OpenAI's Fast mode.                                                                                                    |
| `scale`, `ultrafast` | Accepted by the schema for compatibility. No provider offers them today, so a request naming one has nowhere to route. |

The tier you name is the tier you get. Routing only ever sends the request to a provider that supports it, and the tier is never traded away to reach a cheaper or faster provider. A request that names a tier no provider can serve fails rather than running at a different tier. The response always reports the tier that was served.

## Availability

Tiers are available on select OpenAI, Azure, Vertex AI, and Google AI Studio models, and a model can support different tiers on different providers.

Check before you send: read `supports.service_tier` on each provider block from [`GET /v1/models`](/docs/api-reference/endpoint/list-models), since a tier no provider supports will fail the request. Each supported tier that carries its own rates also appears as an entry in that block's `pricing` array with `condition.service_tier` set; the last entry, with no condition, is the standard rate. The [models page](https://concentrate.ai/models) shows the same data with a per-tier price view.

## Where the tier is reported

| API              | Field                                                 | Values                                                                          |
| ---------------- | ----------------------------------------------------- | ------------------------------------------------------------------------------- |
| Responses        | `service_tier`, top level and on every streamed event | `default`, `flex`, `priority`, `fast`                                           |
| Chat Completions | `service_tier`, top level and on every streamed chunk | `default`, `flex`, `priority`, `fast`                                           |
| Messages         | `usage.service_tier`, plus `usage.speed`              | `standard`, `priority`; `speed: "fast"` accompanies a priority or fast response |

The reported value is always the tier you were billed at, so `"service_tier": "default"` always means standard pricing. Messages uses Anthropic's vocabulary, where `standard` covers both standard and flex billing. The exact billed tier is still on the request's cost breakdown.

## Billing

A request is billed at the pricing entry matching the tier it was served at. If a provider accepts the tier but reports serving a different one, you are billed for what it served.

Tool calls such as web search are billed at their flat rates regardless of tier.

## When a tier is not available

The tier is a required capability of the request, like function calling or image input, and it is never given up in [feature degradation](/docs/api-reference/endpoint/auto-routing#4-feature-degradation). Routing only considers providers that support it, so a tiered request is never quietly served at a price or latency you did not ask for.

* **A tier no provider can serve fails the request.** If you ask for `flex` on a model where no provider offers it, the request errors rather than running at standard rates. Retry without `service_tier` to run at the standard tier.
* **Pinned providers forward the tier as-is.** If you pin a specific provider, for example `azure/gpt-5.6-luna`, the tier is sent to that provider unchanged. If it does not accept the tier, its own error is returned to you.
* **Vertex AI serves its tiers on the global endpoint only.** A Vertex BYOK key pinned to a region runs at standard rates, because the regional host ignores the tier headers.

## Streaming and timeouts

Streaming requests carry the tier on every response event, including `response.created` and the final `response.completed`:

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.concentrate.ai/v1/responses \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "vertex/gemini-3.5-flash",
      "input": "Write a haiku about queues",
      "service_tier": "flex",
      "stream": true
    }'
  ```

  ```python Python theme={null}
  import requests

  with requests.post(
      "https://api.concentrate.ai/v1/responses",
      headers={
          "Authorization": "Bearer YOUR_API_KEY",
          "Content-Type": "application/json"
      },
      json={
          "model": "vertex/gemini-3.5-flash",
          "input": "Write a haiku about queues",
          "service_tier": "flex",
          "stream": True
      },
      stream=True,
      timeout=1800,
  ) as response:
      for line in response.iter_lines():
          print(line)
  ```

  ```typescript TypeScript theme={null}
  const response = await fetch("https://api.concentrate.ai/v1/responses", {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "vertex/gemini-3.5-flash",
      input: "Write a haiku about queues",
      service_tier: "flex",
      stream: true
    })
  });

  const reader = response.body!.getReader();
  const decoder = new TextDecoder();
  for (let read = await reader.read(); !read.done; read = await reader.read()) {
    console.log(decoder.decode(read.value));
  }
  ```
</CodeGroup>

Flex requests can spend several minutes in a queue before producing output, so set a client timeout that covers the wait. Streaming connections stay open through the queue with periodic keepalive events.

Long flex work does not require streaming. A non-streaming flex request gets the serving provider's full flex window, up to 30 minutes on Google providers and 15 minutes on OpenAI. The gateway holds that connection open with whitespace padding in a chunked response body, which JSON parsers ignore. Requests without a tier keep the standard timeout.

## Chat Completions and Messages

The Chat Completions API accepts `service_tier` with the same values and reports the served tier on the response and on every streamed chunk.

The Messages API accepts the tier two ways: Anthropic's fast-mode spelling, `"speed": "fast"`, which is the `fast` tier; or `service_tier` with `flex`, `priority`, or `fast`. When both are sent, `service_tier` wins and `speed` is the fallback. Anthropic's own `service_tier` request values (`auto`, `standard_only`) mean no tier on their own. A request that sends one of them alongside `"speed": "fast"` still runs as `fast`, because fast mode and the tier are independent products.

Because `fast` is its own tier rather than a spelling of `priority`, a model whose providers offer `priority` but not `fast` will reject a fast-mode request. Send `service_tier: "priority"` for those models.

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.concentrate.ai/v1/messages \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "openai/gpt-5.6-luna",
      "max_tokens": 1024,
      "speed": "fast",
      "messages": [{ "role": "user", "content": "Summarize this document..." }]
    }'
  ```

  ```python Python theme={null}
  import requests

  response = requests.post(
      "https://api.concentrate.ai/v1/messages",
      headers={
          "Authorization": "Bearer YOUR_API_KEY",
          "Content-Type": "application/json"
      },
      json={
          "model": "openai/gpt-5.6-luna",
          "max_tokens": 1024,
          "speed": "fast",
          "messages": [{"role": "user", "content": "Summarize this document..."}]
      }
  )

  print(response.json()["usage"]["service_tier"])
  ```

  ```typescript TypeScript theme={null}
  const response = await fetch("https://api.concentrate.ai/v1/messages", {
    method: "POST",
    headers: {
      "Authorization": "Bearer YOUR_API_KEY",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "openai/gpt-5.6-luna",
      max_tokens: 1024,
      speed: "fast",
      messages: [{ role: "user", content: "Summarize this document..." }]
    })
  });

  const data = await response.json();
  console.log(data.usage.service_tier);
  ```
</CodeGroup>