OpenAI's Decisions API is GA: 400 questions, JSON input, caching

OpenAI's Decisions API is generally available as of 22 October 2026, on gpt-6-luna, the only model it supports¹². It answers typed questions about text, images or JSON with probabilities rather than generated text: whether a condition holds, which of your options applies, or where an input sits on your rubric. The beta opened on 6 October with OpenAI's claim that it turns inputs into typed answers "10x faster than the Responses API"¹. GA keeps the price shape, input only, and widens what a single request can carry.

What changed at GA

Some details from the guide matter in code²:

• Three question types. predicate returns a probability between 0 and 1; choice returns one of your values with a probabilities array and a confidence; score returns the probability-weighted average of your level indices, which can fall between levels. Give each question a unique name; the answer echoes it. A question the model declines comes back as refusal.
• JSON is data, not structure. Keys such as role or image_url inside an input_json part "are ordinary data: they don't create messages or fetch images", and input_json is accepted only in user messages.
• What is not accepted. Files, audio and item references; file_id image inputs; developer and system messages carry text only.
• Caching rules. The reusable prefix is the shared input, needs at least 1,024 tokens, and excludes the questions, so keep a reference document or image first and vary the questions. usage.input_tokens_details.cached_tokens and cache_write_tokens are both already inside usage.input_tokens; do not add them.
• Usage counts requests. num_model_requests counts a request with several questions once, so cost per question is yours to derive.

The 15 October changelog also added Decisions inside GPT-Live: a voice session can call Decisions directly or trigger a decision as transcript deltas arrive¹.

What it costs

With gpt-6-luna, uncached input on /v1/decisions costs $0.10 per million tokens and "output tokens are not charged"². Cache reads and writes follow GPT-6 Luna's standard caching rates, which its model page lists as $0.01 per million cached input tokens and $0.125 per million cache-write tokens; prompts over 272K input tokens bill input and cache at twice the rate, and regional processing adds 10 percent where available³. The beta charged nothing for cache reads or writes, so a cache-heavy workload's bill shape changed at GA. The same model on Chat Completions or Responses bills $0.10 input and $0.50 output per million⁴, plus reasoning tokens as output.

When Decisions beats a chat call, and when it loses

OpenAI's guide draws the line itself: use Decisions when your application needs a probability, a choice from a fixed set or a rubric score; use structured outputs "when you need to generate an object that follows your own JSON schema, such as extracted fields or a written explanation", and function calling when the model must request a tool call with arguments².

Decisions wins when you threshold on confidence: routing tickets, flagging content for review, gating a tool call, scoring answers against a rubric. You set thresholds from labelled examples by the cost of false positives and false negatives, as the guide advises, instead of parsing a model's self-reported certainty.

It loses in four cases. It runs on one model, so there is no larger model to escalate a hard case to on the same endpoint. It writes no explanation, which some review and audit workflows require. It takes no audio or files, so speech must be transcribed first. And dependent questions cost a round trip each, since the guide says a decision that depends on an earlier answer needs a separate request².

Moving a beta integration to GA

Nothing in the GA notes says beta requests stop working, and the request shape is the same, so a beta integration keeps running. The changes worth making are about cost and accuracy, not compatibility.

1. Reorder the input for caching. Put the evidence that repeats across requests, such as a policy document, a product catalog excerpt or a reference image, first in input, and keep it byte-identical. It has to reach 1,024 tokens to be cached, and question content never counts toward that².
2. Watch the new cache-write line. Cache writes are charged at GA. A prefix that is written often and read rarely now costs more than it did in beta; check cache_write_tokens against cached_tokens for a day of traffic.
3. Stop flattening JSON. If your code serialised records into a string to fit them into input_text, send them as input_json instead and drop the formatting instructions you wrote to explain the string.
4. Merge request batches that the 200-question limit split. A workload that sent 300 questions about one input in two requests can now send one, which reads the shared input once.
5. Re-derive cost per question. The new usage endpoint counts requests, not questions; divide by the questions you sent, from your own logs, to keep a per-question figure for finance².
6. Recheck thresholds after any input change. Moving from flattened text to JSON, or adding conversation history, changes what the model sees. Re-run your labelled examples and confirm that the probabilities you threshold on still separate the classes you care about.

Calling it through INFRO

INFRO's POST /v1/decisions takes OpenAI's request shape, so OpenAI's SDK (client.decisions.create) works with the base URL and key changed, on your own OpenAI connection, which OpenAI bills directly. The same body can be answered by another decision model you connect, such as TypeSafe's Jev or Cloudflare's Clef, with the answers returned in OpenAI's shape; INFRO's decision policies, rerank, classifier guardrails and route classifier can name GPT-6 Luna's decisions as their engine too. Each call is checked against your key scopes and budgets before the provider is called and recorded with an estimated provider cost.

Stated plainly, INFRO's endpoint was built to the beta request shape and has not caught up with every GA addition. It accepts a string or user messages of input_text and input_image parts, and string instructions. It refuses input_json parts, images inside a question's instructions, and assistant or tool items in input with a 400, and it does not forward prompt_cache_key or explicit cache breakpoints; OpenAI's implicit cache breakpoint still applies on OpenAI's side. Its cost estimate for this endpoint uses the beta rate card (input only, no cache rates), so for cache-heavy traffic it will differ from OpenAI's bill. The 400-question ceiling is enforced by OpenAI, in its own words. Until those gaps close, call OpenAI directly for requests that need the GA-only inputs.