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

URL: https://infro.io/blog/openai-decisions-api-ga
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: Evaluation and models
Format: Guide

> OpenAI made its Decisions API generally available on 22 October 2026, sixteen days after the beta opened. POST /v1/decisions on gpt-6-luna answers predicate, choice and score questions with probabilities; GA raised the limit to 400 questions per request (from 200), added input_json, images inside question instructions, conversation history with tool calls, hosted image URLs and prompt caching. Uncached input costs $0.10 per million tokens and output is not charged; cache reads and writes now bill at GPT-6 Luna's standard caching rates. Use it for classification, routing and scoring where you need a probability; use structured outputs when you need generated fields or an explanation.

Key takeaways:
- The Decisions API went GA on 22 October 2026, sixteen days after its 6 October beta, and gpt-6-luna is still the only supported model.
- A request now takes 1 to 400 questions (200 in beta), structured data through input_json parts, per-question images, conversation history with tool calls, and hosted image URLs.
- Uncached input is $0.10 per million tokens and output is free; GA adds prompt caching, so cache writes are now charged and cache hits bill at the lower cached-input rate, both at GPT-6 Luna's standard caching rates.
- Usage is reported per request, not per question, at GET /v1/organization/usage/decisions.
- Pick Decisions when the answer is a probability over a fixed set; pick structured outputs when the model has to write fields or an explanation.

OpenAI's Decisions API is generally available as of 22 October 2026, on `gpt-6-luna`, the only model it supports[1][2]. 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"[1]. GA keeps the price shape, input only, and widens what a single request can carry.

## What changed at GA

|  | Public beta (6 October) | GA (22 October) |
| --- | --- | --- |
| Questions per request | Up to 200 | 1 to 400 |
| Structured data | As text | `input_json` content parts in user messages |
| Images | Inline base64 | Inline base64 or public HTTP(S) URLs; also inside a question's own `instructions` |
| Input | User text and images | Conversation history: messages plus function and custom tool calls and outputs |
| Caching | Not offered | Prompt caching with an implicit breakpoint; explicit breakpoints and `prompt_cache_key` |
| Usage reporting | Not listed | `GET /v1/organization/usage/decisions` |
| Other |  | Native GPT-Live integration; Private Link |

Table: Decisions API changes at general availability, from OpenAI's Decisions guide and changelog, read 2026-10-27.

Some details from the guide matter in code[2]:

- **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[1].

## What it costs

With `gpt-6-luna`, uncached input on `/v1/decisions` costs $0.10 per million tokens and "output tokens are not charged"[2]. 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[3]. 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[4], plus reasoning tokens as output.

> **Example: One million support tickets, five questions each, at list rates**
> Each ticket is 1,000 tokens and the five questions add 400 tokens of instructions and options.
> 
> - **Decisions, one request per ticket:** 1,400 input tokens × $0.10 / 1M = $0.00014, or $140 per million tickets. Output is free.
> - **Chat Completions with structured outputs on gpt-6-luna, `reasoning_effort: none`:** the same 1,400 input tokens plus about 80 output tokens of JSON: $0.00014 + 80 × $0.50 / 1M = $0.00018, or $180 per million tickets.
> - **The same chat call at the default `medium` effort**, if it reasons for 500 tokens: another 500 × $0.50 / 1M = $0.00025 per ticket, or about $430 per million in total.
> 
> The token counts are assumptions. The gap is modest at GPT-6 Luna's prices; the larger differences are the probabilities, which a structured output does not give you, and the reasoning tokens a chat call may add by default.

## 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[2].

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[2].

## 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].
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[2].
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.

## Questions

### How much does the OpenAI Decisions API cost?

As of 27 October 2026, uncached input on gpt-6-luna costs $0.10 per million tokens on /v1/decisions and output tokens are not charged. Cache reads and writes bill at GPT-6 Luna's standard prompt caching rates ($0.01 per million cached input tokens and $0.125 per million cache-write tokens on its model page), and regional processing premiums and long-context multipliers apply.

### How many questions can one Decisions request ask?

Between 1 and 400 since general availability on 22 October 2026, up from 200 in the public beta. Put independent questions about the same input in one request; a question that depends on an earlier answer needs a separate request.

### Should I use the Decisions API or structured outputs for classification?

Use the Decisions API when the answer is a probability that a condition holds, one option from a fixed set, or a level on a rubric, and you want to act on a threshold. Use structured outputs with the Responses API when the model has to generate fields that follow your own schema or write an explanation. OpenAI's Decisions guide draws the same line.

### Which models and inputs does the Decisions API support?

Only gpt-6-luna, as of 27 October 2026. Inputs are text, images (inline base64 or public HTTP or HTTPS URLs) and JSON through input_json parts in user messages, plus conversation history with function and custom tool calls. Files, audio, item references and file_id images are not supported.

### Can I call OpenAI's Decisions API through INFRO?

Yes, with OpenAI's SDK pointed at INFRO's base URL and an INFRO gateway key, on your own OpenAI connection. INFRO's endpoint accepts the beta request shape: text and image parts in user messages and string instructions. GA additions such as input_json, images inside question instructions, conversation items and explicit cache controls are not supported through INFRO yet; send those requests to OpenAI directly.

## Sources

1. Changelog — OpenAI. https://developers.openai.com/api/docs/changelog (accessed 2026-10-27)
2. Decisions — OpenAI. https://developers.openai.com/api/docs/guides/decisions (accessed 2026-10-27)
3. GPT-6 Luna model page — OpenAI. https://developers.openai.com/api/docs/models/gpt-6-luna (accessed 2026-10-27)
4. Pricing — OpenAI. https://developers.openai.com/api/docs/pricing (accessed 2026-10-27)