Service Tiers

Trade off latency, availability, and cost by requesting a processing tier for supported models.

Some models offer different processing tiers that trade off latency, availability, and cost. You can request a service tier on your chat completion request, and BLACKBOX AI adjusts pricing based on the tier that was actually served.

Setting a service tier on a model that doesn't support it has no effect. Tier availability varies by model, so check the LLM Pricing page for current per-tier rates.

Supported values

Value	Description
`default`	Standard processing tier
`priority`	Higher availability and faster processing at increased cost

If you don't specify a service tier, requests use the standard (default) tier.

Supported models

The priority service tier is currently supported on the following models:

Model
`openai/gpt-5.5`
`openai/gpt-5.6-sol`
`openai/gpt-5.6-luna`
`openai/gpt-5.6-terra`

Requesting service_tier: "priority" on any other model has no effect and the request runs on the default tier.

Best-effort routing

Service tier is a best-effort routing hint, not a hard guarantee. If the model serving a request doesn't support service tiers, the tier is ignored and the request runs on the default tier. If a model supports the tier but doesn't grant it (for example, when priority capacity is full), the request is downgraded to the default tier. In both cases the request still succeeds and is billed at the default rate.

The only request that fails over a service tier is one that passes an invalid value. The service_tier field accepts default or priority.

Setting the service tier

Pass the service_tier field in the request body:

curl -X POST https://enterprise.blackbox.ai/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.5",
    "messages": [{"role": "user", "content": "Explain quantum computing in two sentences."}],
    "service_tier": "priority"
  }'

import requests

response = requests.post(
    "https://enterprise.blackbox.ai/chat/completions",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    },
    json={
        "model": "openai/gpt-5.5",
        "messages": [{"role": "user", "content": "Explain quantum computing in two sentences."}],
        "service_tier": "priority"
    }
)

data = response.json()
print(data["choices"][0]["message"]["content"])
print("Applied tier:", data.get("service_tier"))

const response = await fetch("https://enterprise.blackbox.ai/chat/completions", {
    method: "POST",
    headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    },
    body: JSON.stringify({
        model: "openai/gpt-5.5",
        messages: [{ role: "user", content: "Explain quantum computing in two sentences." }],
        service_tier: "priority"
    })
});

const data = await response.json();
console.log(data.choices[0].message.content);
console.log("Applied tier:", data.service_tier);

Reading the applied service tier

The tier that was actually served appears on the response as the service_tier field. BLACKBOX AI only sets this field to priority when the request was served at priority. If the request was downgraded to standard, the field is omitted or returned as default, so a missing value is an honest signal that you weren't billed at the requested tier.

{
  "id": "gen-...",
  "model": "openai/gpt-5.5",
  "choices": [...],
  "usage": {...},
  "service_tier": "priority"
}

BLACKBOX AI bills the request at the tier that was actually served, not the tier you requested.

Streaming

Service tiers work the same way with streaming. Set service_tier in the request body and read the applied tier from the response chunks once the stream completes.

curl -N -X POST https://enterprise.blackbox.ai/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.5",
    "messages": [{"role": "user", "content": "Explain quantum computing in two sentences."}],
    "stream": true,
    "service_tier": "priority"
  }'

import json
import requests

response = requests.post(
    "https://enterprise.blackbox.ai/chat/completions",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    },
    json={
        "model": "openai/gpt-5.5",
        "messages": [{"role": "user", "content": "Explain quantum computing in two sentences."}],
        "stream": True,
        "service_tier": "priority"
    },
    stream=True
)

service_tier = None
for line in response.iter_lines():
    if not line:
        continue
    data = line.decode("utf-8").removeprefix("data: ")
    if data == "[DONE]":
        break
    chunk = json.loads(data)
    delta = chunk["choices"][0].get("delta", {})
    if delta.get("content"):
        print(delta["content"], end="", flush=True)
    if chunk.get("service_tier"):
        service_tier = chunk["service_tier"]

print("\nApplied tier:", service_tier)

const response = await fetch("https://enterprise.blackbox.ai/chat/completions", {
    method: "POST",
    headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    },
    body: JSON.stringify({
        model: "openai/gpt-5.5",
        messages: [{ role: "user", content: "Explain quantum computing in two sentences." }],
        stream: true,
        service_tier: "priority"
    })
});

const reader = response.body.getReader();
const decoder = new TextDecoder();
let serviceTier;

while (true) {
    const { value, done } = await reader.read();
    if (done) break;
    for (const line of decoder.decode(value).split("\n")) {
        const data = line.replace(/^data: /, "").trim();
        if (!data || data === "[DONE]") continue;
        const chunk = JSON.parse(data);
        const delta = chunk.choices[0]?.delta;
        if (delta?.content) process.stdout.write(delta.content);
        if (chunk.service_tier) serviceTier = chunk.service_tier;
    }
}

console.log("\nApplied tier:", serviceTier);

Benchmark results

The table below compares the default (standard) and priority tiers on the same workload. The priority tier delivers a faster time-to-first-token (TTFT), lower end-to-end (E2E) latency, and higher output throughput (tokens per second).

Metric	Standard (avg)	Priority (avg)	Δ	% change
TTFT	3088.9 ms	2666.9 ms	−422 ms	−13.7% (faster)
E2E	5301.2 ms	4623.1 ms	−678 ms	−12.8% (faster)
Output TPS	124.0	140.0	+16.0	+12.9% (higher)

Percentiles

Metric	p50 (Standard → Priority)	p90 (Standard → Priority)
TTFT	2870 → 2586 ms	4248 → 3755 ms
E2E	5257 → 4577 ms	6250 → 5287 ms
TPS	127 → 139	139 → 171

Actual numbers vary by model, prompt, output length, and load. These results are representative measurements, not guaranteed performance.