# LLM service tiers compared: Flex, Fast, Ultrafast and Priority

URL: https://infro.io/blog/llm-service-tiers-compared-2026
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-10-27
Last modified: 2026-10-27
Last reviewed: 2026-10-27 (next review due 2026-11-26)
Topic: Routing and reliability
Format: Comparison

> Service tiers sell the same model at different speeds and prices. OpenAI's Flex bills at Batch rates for slower, sometimes unavailable responses; Fast (formerly Priority processing) costs twice Standard for up to 2.5x speed; Ultrafast for GPT-6.1 Sol lists $12 input and $60 output per million tokens up to 272K input, six times Standard. Anthropic's fast mode for Claude Opus 5.5 costs $8 and $40, twice standard, for up to 2.5x output speed, and new Priority Tier commitments are no longer sold. Gemini's Flex is half price with a 1 to 15 minute latency target and its Priority costs 75 to 100 percent more. Pay for speed only on paths where a person is waiting and output speed, not time to first token or tool latency, is the bottleneck.

Key takeaways:
- OpenAI's Fast mode replaced Priority processing on 30 July 2026, costs twice Standard and claims up to 2.5x faster speeds; `service_tier: "priority"` still works.
- OpenAI Ultrafast for GPT-6.1 Sol lists $12 input, $0.60 cached and $60 output per million tokens up to 272K input, six times Standard; the guide publishes no speed figure.
- Anthropic's fast mode for Opus 5.5 left research preview on 15 October 2026: `speed: "fast"`, $8 and $40 per million, up to 2.5x output tokens per second, not faster time to first token.
- Anthropic no longer sells new Priority Tier commitments, and Priority Tier does not cover Opus 5.5, Sonnet 5.5 or Haiku 5.5.
- Gemini Flex is half price with a 1 to 15 minute latency target; Gemini Priority costs 75 to 100 percent more and downgrades to Standard instead of failing.
- Each premium tier fails differently at capacity: OpenAI Fast downgrades and bills Standard, Anthropic fast mode returns 429, Gemini Priority downgrades. Your fallback code has to match.

Model APIs now sell the same model at several speeds. A request can be processed slower and for less, at the standard rate, or faster for a premium, and the parameter that chooses is one field in the request body. OpenAI calls the options service tiers (Flex, Standard, Fast, Ultrafast)[1]; Anthropic has fast mode for Claude Opus 5.5 and a Priority Tier it no longer sells[2][3]; Google's Gemini API has Flex and Priority, both in preview[4][5].

The short answer to "which tier should we use" is: standard by default, a slow tier for anything nobody is waiting on, and a fast tier only on the few user-facing paths where output speed is measurably the bottleneck. The rest of this guide gives the prices, the promises and the failure behaviour you need to make that call.

## The tiers side by side

| Vendor and tier | How to ask for it | Price against standard | What it promises | When capacity runs out |
| --- | --- | --- | --- | --- |
| OpenAI Flex | `service_tier: "flex"` | Batch rates (half) | Slower responses, occasional unavailability | `429 Resource Unavailable`, not charged |
| OpenAI Fast | `service_tier: "fast"` or `"priority"` | Twice Standard | Up to 2.5x faster, more consistent latency | Ramping too fast downgrades to Standard, billed at Standard |
| OpenAI Ultrafast | `service_tier: "ultrafast"` | Six times Standard on GPT-6.1 Sol | Fastest tier; no figure in the guide | Separate rate limits; behaviour not documented |
| Anthropic fast mode | `speed: "fast"` | Twice standard on Opus 5.5 | Up to 2.5x output tokens per second | `429` or `529` error |
| Anthropic Priority Tier | Existing commitments only | Committed capacity | Prioritized requests, 99.5% uptime target | Overflow falls back to standard |
| Gemini Flex | `service_tier: "flex"` | Half | Minutes, 1 to 15 minute target | `503` or `429`, no fallback |
| Gemini Priority | `service_tier: "priority"` | 75 to 100 percent more | Second response times, non-sheddable | Downgraded to Standard, billed at Standard |

Table: Service tiers on the three largest model APIs, from the vendors' pages read 2026-10-27.

Every row comes from the vendor's own page[6][7][8][2][3][5][4]. Two of the speed claims are "up to", which is a ceiling, not a typical value. None of the three vendors publishes a latency number for its fastest tier that you can plan against.

## OpenAI: Flex, Fast and Ultrafast

OpenAI's pricing page lists five ways to process a request: Standard, Batch, Flex, Fast and Ultrafast, and notes that Priority processing was renamed Fast mode on 30 July 2026[9]. The changelog entry says requests tagged `priority` automatically use Fast mode[10].

| GPT-6.1 Sol, per million tokens, up to 272K input | Input | Cached input | Output |
| --- | --- | --- | --- |
| Flex (same as Batch) | $1.00 | $0.05 | $5.00 |
| Standard | $2.00 | $0.10 | $10.00 |
| Fast | $4.00 | $0.20 | $20.00 |
| Ultrafast | $12.00 | $0.60 | $60.00 |

Table: GPT-6.1 Sol list prices by tier, from OpenAI's pricing page, read 2026-10-27. Above 272K input tokens, input doubles and output is 1.5 times.

**Fast** is a pay-as-you-go tier for user-facing applications; OpenAI describes "up to 2.5× faster speeds and more consistent latency"[7]. It can be set per request or as a project default. Standard and Fast share one rate limit for a given model. The catch is the ramp limit: if traffic grows too quickly, some Fast requests are downgraded to standard speed, billed at standard rates, and report `service_tier: "default"`. OpenAI's rule of thumb is that once traffic reaches 1M input tokens per minute, you increase it by no more than 50 percent every 15 minutes, and it advises against running large ETL or batch jobs in Fast mode[7]. GPT-6 Astra's Fast mode has no latency SLA[7].

**Ultrafast** is OpenAI's fastest tier. The guide lists GPT-6.1 Sol and GPT-6 Astra, available to all API users, with its own rate limits (for GPT-6.1 Sol, 1M tokens per minute on the Build tier by default) and a strong recommendation to use WebSockets, because "without a persistent connection, network overhead can reduce the latency gains"[8]. The changelog dates Ultrafast for GPT-6.1 Sol in the Responses API to 8 October 2026[10]. When OpenAI announced Ultrafast in limited preview on 13 August, for GPT-5.6 Sol, it said "up to 14x faster than Standard processing"[10]; the current guide gives no speed figure and does not describe what happens when Ultrafast capacity is short[8]. GPT-6 Luna has no Ultrafast price[9].

**Flex** bills at Batch rates for Responses or Chat Completions requests "in exchange for slower response times and occasional resource unavailability", is in beta with limited model availability, and returns `429 Resource Unavailable` when there is no capacity, without charging[6]. OpenAI suggests raising the SDK timeout to 15 minutes and either backing off or retrying with `service_tier: "auto"` when finishing matters more than price[6].

Since 21 October 2026, OpenAI also lets you choose which service tiers each project may use in Platform settings[10]. That is the control a finance lead should ask about first.

## Anthropic: fast mode, and the end of Priority Tier

Anthropic's fast mode runs "the same model with a faster inference configuration", with up to 2.5x higher output tokens per second; the gain is in output speed, not time to first token, and is most visible when streaming[2]. You opt in with `speed: "fast"` on a Messages request. On 15 October 2026 fast mode for Claude Opus 5.5 left research preview: no access request, no beta header, and a default fast mode rate limit in the Start, Build and Scale usage tiers. It is also available on Claude in Microsoft Foundry for Azure-hosted deployments[11], and on Claude Models on Google Cloud (Anthropic managed)[2].

Fast mode for Opus 5.5 costs $8 input and $40 output per million tokens across the full context window, twice the standard $4 and $20; caching and data residency multipliers stack on top, and it is not available with the Batch API or with a Priority Tier commitment[2]. When the fast mode limit or capacity is exhausted the API returns a `429` or `529`, and the response's `usage.speed` field says which speed served a successful request. Falling back to standard speed is your code's job, and Anthropic warns that it misses the prompt cache, because requests at different speeds do not share cached prefixes[2].

Priority Tier is a different thing: committed capacity that Anthropic prioritizes over other traffic, with a 99.5 percent uptime target and overflow falling back to standard[3]. The page now opens with a warning that commitments "are no longer available for purchase"; existing ones run to their contract end, and it does not support Fable 5.1, Opus 5.5, Sonnet 5.5 or Haiku 5.5[3]. If a Priority Tier commitment is part of your reliability plan, it ends with the contract or with a move to a current model, whichever comes first.

## Google: Gemini Flex and Priority

Google's Gemini API offers both, in preview, on the Interactions API[4][5]. Priority costs 75 to 100 percent more than Standard and is "designed for second response times for interactive, user-facing AI tools". It is non-sheddable, its default limits are 0.3 times the standard rate limit, and when limits are exceeded overflow requests are downgraded to Standard and billed at Standard rather than failing; the `x-gemini-service-tier` response header shows it[4]. Flex is half price with a latency target of 1 to 15 minutes, can be preempted during standard-traffic spikes, returns `503` or `429` with no server-side fallback, and Google recommends client timeouts of 10 minutes or more[5]. Both list the current Gemini models, including Gemini 4 Argon and Gemini 3.8 Flash.

## What the premium costs per request

> **Example: Illustrative: one chat answer at each tier**
> At list rates. A support answer sends 2,000 input tokens and streams 500 output tokens, with no cache hits.
> 
> GPT-6.1 Sol: Flex $0.0045, Standard $0.009, Fast $0.018, Ultrafast $0.054 per answer. At one million answers a month that is $4,500, $9,000, $18,000 and $54,000.
> 
> Claude Opus 5.5: standard $0.018, fast mode $0.036 per answer, or $18,000 and $36,000 a month.
> 
> The token counts are hypothetical. Reasoning tokens, billed as output, would raise every figure in the same proportion.

The arithmetic is simple and it is the point: a fast tier doubles or sextuples the cost of every request it touches. Applying it to the whole workload by setting a project default is the most expensive way to buy speed, and OpenAI's ramp limit means a sudden switch may not even deliver it[7].

## When paying for speed is worth it

Paying for speed works when three things are true together: a person is waiting, the answer is long enough that output rate dominates what they feel, and faster output changes something you measure. A streamed code edit, a long drafted reply or a voice agent's turn can meet all three.

It usually loses in these cases:

- **Short answers.** A 50-token classification is dominated by time to first token and network, and Anthropic is explicit that fast mode targets output speed, not time to first token[2].
- **Agent loops.** If most of a turn is spent in tools, retrieval or your own code, faster generation shortens the smallest part.
- **Background work.** Evaluations, enrichment and nightly jobs belong on Flex or Batch, where the same tokens cost half[6][5].
- **Capacity insurance.** OpenAI Fast and Gemini Priority downgrade under load, and Anthropic fast mode errors. None of them is a guarantee of speed when demand spikes, which is often when you wanted it.

The slow tiers lose when the work has a deadline: a Flex request can wait minutes or fail with no fallback, so anything a user or a downstream SLA depends on needs a retry path to standard.

## The CEO question: which paths justify it

For a leader, the decision is not per vendor but per path. Ask the team for a list of user-facing paths with, for each: the model, the median and 95th percentile time to first token and total response time, the output length, and the business metric that latency is believed to move. Then ask three questions.

1. **Where is time actually spent?** If time to first token or tools dominate, a fast tier buys little.
2. **What would the premium cost at current volume?** Use the multipliers above: twice standard for OpenAI Fast and Anthropic fast mode, six times for GPT-6.1 Sol Ultrafast, up to twice for Gemini Priority.
3. **Who can turn it on?** A project default or one config change can move all traffic to a premium tier. OpenAI's per-project tier permissions exist for this[10]; make sure someone owns them.

A sound policy fits on one line: standard everywhere, Flex or Batch for background work, a fast tier on named paths with a measured reason and an owner, reviewed monthly against the invoice.

## Watching tiers and their cost with INFRO

INFRO is a control plane that sits between your applications and the provider accounts you already hold. Your providers bill you directly at whatever tier served each request; INFRO does not change provider prices or capacity.

**Measure before you pay.** Each request INFRO records carries its latency and time to first token, and [usage analytics](https://infro.io/docs/observability/analytics) return p50, p95 and p99 latency by model, project and key, so you can see which paths are slow before buying speed. [Traffic changes](https://infro.io/docs/observability/traffic-changes) raise a finding when a scope's p95 latency or time to first token shifts.

**Fall back without code.** A [route](https://infro.io/docs/routes) with [failover](https://infro.io/docs/features/fallbacks) moves a request to another target on your own connections when one fails, which covers the "premium tier is out of capacity" case for errors the gateway sees.

**Parameters pass through.** On `/v1/chat/completions`, top-level parameters INFRO does not model are forwarded to the provider unchanged ([chat completions reference](https://infro.io/docs/api/chat-completions)), so `service_tier` reaches an OpenAI connection as you sent it.

What INFRO does not do today: its per-request cost estimate uses the standard list or negotiated rate and does not apply a tier premium, so a Fast or Ultrafast request is estimated at its standard price. [Provider cost reconciliation](https://infro.io/docs/cost/reconciliation) compares INFRO's estimates with your provider's own cost report, which is where tier charges show up; treat the gap as the cost of the tiers you chose.

## Questions

### What is OpenAI's service_tier parameter?

It selects how a request is processed. OpenAI's reference lists `auto` (the project's configured tier, the default), `default` (standard), `flex`, `fast` or `priority` (both opt into Fast mode) and `ultrafast`. The response's `service_tier` field reports the tier that actually served the request, so check it rather than assuming.

### Is OpenAI Priority processing gone?

It was renamed. OpenAI's changelog says Fast mode replaced Priority processing on 30 July 2026, and requests tagged `priority` automatically use Fast mode. For GPT-5.6 and earlier, the response field still reports `priority`.

### How much faster is Claude fast mode?

Anthropic says up to 2.5x higher output tokens per second on Claude Opus 5.5, with the gain focused on output speed rather than time to first token. It costs $8 input and $40 output per million tokens, twice standard Opus 5.5, and is not available with the Batch API.

### Can I still buy Anthropic Priority Tier?

No. Anthropic's service tiers page says Priority Tier commitments are no longer available for purchase; existing commitments run to their contract end date, and it points customers who need guaranteed capacity to sales. Priority Tier does not support Opus 5.5, Sonnet 5.5 or Haiku 5.5.

### When is a fast tier worth paying for?

When a person is waiting on a long streamed answer, the stream's output rate is what they notice, and faster output changes a measured outcome such as completion or conversion. It is rarely worth it for background jobs, short answers dominated by time to first token, or agent loops whose time goes to tools.

## Sources

1. Responses API reference — OpenAI. https://developers.openai.com/api/reference/python/resources/beta/subresources/responses/methods/retrieve (accessed 2026-10-27)
2. Fast mode — Anthropic. https://platform.claude.com/docs/en/build-with-claude/fast-mode (accessed 2026-10-27)
3. Service tiers — Anthropic. https://platform.claude.com/docs/en/api/service-tiers (accessed 2026-10-27)
4. Priority inference — Google. https://ai.google.dev/gemini-api/docs/priority-inference (accessed 2026-10-27)
5. Flex inference — Google. https://ai.google.dev/gemini-api/docs/flex-inference (accessed 2026-10-27)
6. Flex processing — OpenAI. https://developers.openai.com/api/docs/guides/flex-processing (accessed 2026-10-27)
7. Fast mode — OpenAI. https://developers.openai.com/api/docs/guides/fast-mode (accessed 2026-10-27)
8. Ultrafast mode — OpenAI. https://developers.openai.com/api/docs/guides/ultrafast-mode (accessed 2026-10-27)
9. Pricing — OpenAI. https://developers.openai.com/api/docs/pricing (accessed 2026-10-27)
10. Changelog — OpenAI. https://developers.openai.com/api/docs/changelog (accessed 2026-10-27)
11. Claude Platform API release notes — Anthropic. https://platform.claude.com/docs/en/release-notes/api (accessed 2026-10-27)