OpenAI Adds Service Tier Controls for API Projects

Somebody on your team sets service_tier to fast, and every token on that route now costs twice as much. As of October 21, OpenAI service tier controls let you shut that down per project, or for every project at once from organization settings.

What the OpenAI service tier controls do

The October 21 changelog entry is two sentences: "You can now choose which service tiers projects can use in Platform settings." and "Organization settings can restrict service tiers for all projects."

OpenAI's error-codes guide fills in the rules:

• The policy covers default, flex and priority. A fast request is evaluated as priority.
• Scale Tier is outside the policy.
• Projects cannot enable a tier the organization has blocked, so the organization always wins.
• A request that picks, or resolves to, a blocked tier fails with HTTP 400, type invalid_request_error, and error.param set to service_tier. The message reads: "Invalid service_tier argument: The requested service tier is not allowed for this project."

I could not find a statement on how ultrafast is treated. Test it before you rely on it.

What each GPT-6 tier costs and where it fits

Fast mode replaced Priority Processing on July 30, and requests tagged priority use it automatically, so OpenAI priority processing and Fast are the same lever. Here are gpt-6.1-sol list prices from the pricing page, per 1M tokens, short context (up to 272K input tokens):

| Tier | Input | Output | Versus Standard | Where it fits | | --- | --- | --- | --- | --- | | Flex | $1 | $5 | 0.5x | Evals, backfills and overnight jobs that can wait or retry | | Standard | $2 | $10 | 1x | Everything else | | Fast | $4 | $20 | 2x | Interactive features where a user is watching a spinner | | Ultrafast | $12 | $60 | 6x | A few latency-critical paths, if any |

gpt-6-astra follows the same multiples: $10 input and $50 output on Standard, $60 and $300 on Ultrafast. Flex is billed at Batch rates and is still in beta with limited model availability.

A quick illustration: 100M output tokens a month on gpt-6.1-sol is $1,000 on Standard, $2,000 on Fast and $6,000 on Ultrafast, at list prices, output only. One misconfigured batch job on a premium tier turns into a budget meeting.

Set up tier restrictions on Monday morning

1. Set the organization ceiling. Allow the union of tiers any project needs, then narrow per project. A sensible start (my suggestion, not OpenAI's): Standard and Flex everywhere, Fast only on projects with a user-facing latency target.
2. Check each project's default tier. In Settings, under Project, General, Project Service Tier can be set to Fast, and requests without a service_tier then default to Fast. Block priority on such a project and every untagged call can fail until someone changes the default.
3. Smoke test every project key. The script below sends a 16-token request on each tier using the cheapest GPT-6 model.
4. Log the tier you actually got. Read response.service_tier. The Fast mode guide says a request downgraded by the ramp rate limit comes back as default and bills at standard rates.

import os
from openai import OpenAI, BadRequestError, RateLimitError

client = OpenAI(api_key=os.environ["OPENAI_PROJECT_KEY"])

for tier in ["default", "flex", "fast"]:
    try:
        r = client.responses.create(
            model="gpt-6-luna",
            input="ping",
            max_output_tokens=16,
            service_tier=tier,
        )
        print(f"{tier}: allowed, response tier = {r.service_tier}")
    except BadRequestError as e:
        if e.param != "service_tier":
            raise
        print(f"{tier}: blocked by policy: {e.message}")
    except RateLimitError:
        print(f"{tier}: allowed by policy, but rate limited (429)")

Run it once per project key. A blocked tier prints the policy message; an allowed one prints the tier the response reports. The real costs are a few cents at most, but run it against a test project if you can.

Gotchas

• A 400 will not fix itself. Keep it out of retry loops and alert on it instead.
• auto and omitted tiers can still fail. If the tier they resolve to is blocked, you get the same error.
• Flex fallbacks follow the default. On a Flex 429 (no charge), the Flex guide suggests retrying with auto or dropping the parameter, which lands on the project's default tier. Make sure that tier is allowed.
• Scale Tier is not capped by this policy. It is also billed separately from Fast mode, with no automatic spillover.
• Ultrafast has its own caveats. For gpt-6-astra, the changelog says it is subject to rate limits, with global processing and US data residency, and no EU or other regional residency.

Tier choice used to be one line of code anyone could change; now it is a policy someone owns, which is the difference between a surprise invoice and a budget you set on purpose.