OpenAI has made its Decisions API generally available, giving developers a dedicated way to handle frequent, bounded decisions inside applications and agents. Rather than asking a model to write a full response, a developer defines a question and the acceptable answer format. The API then returns a typed result an application can use to classify an input, route a request or decide what to do next.
Announced on October 22, 2026, the API is built on GPT-6 Luna and accepts text, images and structured JSON. OpenAI says it can make these decisions up to 10 times faster than GPT-6 Luna called through the Responses API. That is OpenAI’s comparison, not a guarantee of a particular response time for every application or request. ([openai.com](https://openai.com/index/decisions-api/))
What the Decisions API does
Many software workflows need a judgment, not a paragraph: Is this message about billing? Which team should handle this case? Does this image show visible damage? How urgent is this support issue? Traditionally, a developer might ask a general-purpose model to answer in a prescribed format, then parse the output and handle formatting errors. Decisions is designed to make the bounded question and its typed answer the central part of the API request.
The endpoint is POST /v1/decisions. The current documentation lists gpt-6-luna as the only supported model for this endpoint. Inputs can combine text with images or structured data, and a request can include multiple questions about the same context. The general-availability release raised the limit to 400 questions per request, up from 200 in the public beta. ([openai.com](https://openai.com/index/decisions-api/))
What changed at general availability
OpenAI says the API has added several capabilities since its public beta. Developers can reuse shared context with prompt caching, pass structured data using native JSON input, and add images to individual question instructions. The request limit is now 400 questions. The API also has a native integration with GPT-Live, which can trigger decisions as conversation transcripts arrive or let Live call the Decisions API directly. OpenAI additionally lists inference residency in the United States and Europe, with eligibility and configuration details available in its documentation. ([openai.com](https://openai.com/index/decisions-api/))
Those additions make the service relevant to more than basic text classification. A document workflow could provide extracted text or JSON alongside an image and ask a set of defined questions. A live voice app could choose whether to clarify, route or escalate a request while a conversation is underway. In each case, the application still controls the allowed outcomes and what actions follow.
How to put it to work
Start with a repeated decision that has a clear set of outcomes. Write down the question, the evidence the model should consider, and how your software will use the answer. For routing a customer complaint, for example, define the supported departments and provide short descriptions that make the categories distinct. Include an “other” or escalation path when inputs may not fit the main options.
A minimal request uses the dedicated endpoint, names the supported model, provides input and declares a typed question. For example, a routing question can specify a choice from values your application understands:
curl https://api.openai.com/v1/decisions
-H 'Authorization: Bearer $OPENAI_API_KEY'
-H 'Content-Type: application/json'
-d '{
"model": "gpt-6-luna",
"input": "I was charged twice for my order.",
"questions": [{
"type": "choice",
"name": "department",
"instructions": "Which department should handle this complaint?",
"choices": [
{"value": "billing", "description": "Payments, invoices, and refunds."},
{"value": "technical", "description": "Problems using the product."},
{"value": "shipping", "description": "Delivery and tracking."},
{"value": "other", "description": "Requests outside these categories."}
]
}]
}'This is an illustrative request based on the documented endpoint and schema. In production, keep the API key on your server, inspect the returned answer type, and map returned values to explicit application behavior. OpenAI’s guide also shows using its SDKs and supports text, image and JSON inputs. Developers can try questions in the Decisions Playground before integrating them into an application. ([developers.openai.com](https://developers.openai.com/api/docs/guides/decisions))
Evaluate the decision before automating the action
Typed output reduces the work of turning a model response into an application value, but it does not make a judgment infallible. Test the question against examples from real usage, including ambiguous cases, unusual phrasing, missing details and inputs that belong in a fallback category. Review false positives and false negatives separately: a routing error may have different consequences from an incorrect urgency score.
Set action thresholds in your own application and decide what should happen when confidence is low, the model refuses, or the result is unexpected. For consequential workflows, a safer design can send uncertain cases to a person rather than automatically taking an irreversible action. Treat confidence and probabilities as model outputs to evaluate on your own data, not as proof that an answer is correct or calibrated for your use case.
Also make the rubric operational. For a score question, describe each level in observable terms and keep the order meaningful. For choices, avoid overlapping categories and spell out what each option covers. For image questions, state what evidence matters and what should be ignored. These steps make the task clearer; they do not guarantee a particular accuracy level.
Pricing and practical limits
OpenAI’s published Decisions API pricing lists $0.10 per million uncached input tokens and $0.01 per million cached input tokens. There are no output-token charges. Cache writes, regional processing premiums and long-context pricing rules can affect the bill, so check the current pricing guide for the full calculation. OpenAI also says usage reporting is available through an organization endpoint; its documentation notes that request counts count API requests, not the individual questions inside a request. ([openai.com](https://openai.com/index/decisions-api/?utm_source=openai))
Several boundaries are worth planning around. GPT-6 Luna is the only model currently documented for the endpoint. The “up to 10× faster” statement is a company-reported comparison against GPT-6 Luna through the Responses API, not a service-level promise. Actual latency depends on the request and operating conditions. The endpoint is designed for typed, bounded answers, so it may not be the right fit for tasks that require free-form writing or multi-step reasoning. And, as with any model-backed feature, developers should evaluate outputs, monitor behavior and provide a fallback appropriate to the risks of the workflow.
FAQ
What is the OpenAI Decisions API?
It is an API for asking bounded questions about text, images or structured inputs and receiving typed answers—probabilities, choices from a supplied set or scores against a rubric—that an application can use.
When did it become generally available?
OpenAI announced general availability on October 22, 2026. Its developer documentation identifies POST /v1/decisions as the endpoint and gpt-6-luna as the currently supported model. ([openai.com](https://openai.com/index/decisions-api/))
Does the API charge for generated output tokens?
No. OpenAI says there are no output-token charges for Decisions API requests. Input-token charges still apply, and caching or other pricing conditions may affect the rate.
Is it always 10 times faster than the Responses API?
No. OpenAI describes performance as “up to” 10 times faster than GPT-6 Luna through the Responses API. That is a maximum comparison stated by OpenAI, not a guarantee for every application, request or operating condition.
Can the API make a final decision without human review?
An application can use the result to trigger an action, but whether it should do so depends on the workflow’s risk and your own evaluation. For uncertain or high-impact cases, build in escalation, human review or another safe fallback rather than assuming a typed answer is automatically correct.
Bottom line
The OpenAI Decisions API gives developers a focused option for recurring app and agent decisions that fit a defined answer space. Its typed outputs, multimodal inputs, caching and GPT-Live integration may help teams build faster classification and routing paths without generating a full response. The practical value will depend on whether the task is truly bounded, how carefully its choices and rubrics are designed, and how well the implementation handles uncertainty.
