Service Tiers

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:

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

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"])

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);

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

{
  "id": "resp_abc123",
  "status": "completed",
  "service_tier": "flex",
  "usage": { "input_tokens": 1204, "output_tokens": 96, "total_tokens": 1300 }
}

Tier values

string

default:"auto"

One of auto, default, flex, scale, priority, fast, or ultrafast.

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, 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 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. 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:

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

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)

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));
}

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.

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

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"])

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);

Responses

Chat Completions (Beta)

Messages (Beta)

Models API

Features

Utilities

Reference

Catalog

Overview

Tier values

Availability

Where the tier is reported

Billing

When a tier is not available

Streaming and timeouts

Chat Completions and Messages

​Overview

​Tier values

​Availability

​Where the tier is reported

​Billing

​When a tier is not available

​Streaming and timeouts

​Chat Completions and Messages

Overview

Tier values

Availability

Where the tier is reported

Billing

When a tier is not available

Streaming and timeouts

Chat Completions and Messages