Are you handling classification, simple choices, and scoring against fixed criteria with a long model response every time? The OpenAI Decisions API is a beta API in which you declare these bounded judgments as question types and get structured answers back for your input. The documentation published on October 6, 2026 lets you check the actual request format, image input, and how to connect voice apps.
This post focuses on calling the new API directly and looking at its operating conditions. For the original DevDay announcement, the speed comparison, and the Jev story, continue with the earlier Decisions API introduction.
What does the Decisions API do?
Where a typical generation API is used to produce broad answers, the Decisions API evaluates questions of a predefined shape against your input. A request consists of model, a shared input, and an ordered list of questions, and the current docs use the gpt-6-luna model as the example. The official path is POST /v1/decisions. If you put the three types below into one request together, you share the input and get a different result for each.
- predicate: Returns the likelihood that a statement about the input is true, as a number.
- choice: Picks one of the values you define and gives per-candidate probabilities and a confidence.
- score: Returns an integer score against an ordered rubric, plus per-level probabilities.
Question order is reflected in the order of the answers, so it is easy to match them up in your application. But each answer can come back as a refusal, so don't assume only successful values arrive, and check the response type.
DECISIONS · INTERACTIVE EXAMPLES
Tap a question type to see the shape of the result
The same input becomes a probability, a selected value, or a score depending on how you define the question. Expand each item to compare the core of the request and the shape of the response.
Examples and structure are based on the official OpenAI Decisions guide, adapted for this post. The figures and results shown are examples from the guide, not live API responses.
Request and response example
The example below determines whether a customer message is a damage report, picks a handling route, and rates urgency on a fixed three-level scale. Narrow the instructions and choices to fit your real input.
curl https://api.openai.com/v1/decisions \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-6-luna",
"input": "The box arrived crushed and the glass bottle inside is broken.",
"questions": [
{
"type": "predicate",
"name": "damage_report",
"instructions": "Did the customer explicitly report that the item was damaged in shipping?"
},
{
"type": "choice",
"name": "route",
"instructions": "Pick the single handling route that best fits the message.",
"choices": [
{ "value": "replacement", "description": "Damaged or defective item" },
{ "value": "tracking", "description": "Shipping location inquiry" },
{ "value": "other", "description": "Any other inquiry" }
]
},
{
"type": "score",
"name": "urgency",
"instructions": "Rate how urgently the customer needs a response.",
"levels": [
{ "label": "low", "description": "Not urgent" },
{ "label": "normal", "description": "Needs a routine check" },
{ "label": "high", "description": "Needs quick action" }
]
}
]
}'In the response, answers holds the result for each question type in input order. A predicate returns probability, a choice returns the selected choice, its confidence, and per-candidate probabilities, and a score returns an integer score and per-level probabilities. So you can spell out rules in your application, like applying a threshold or handing low-confidence results to a person. Decisions produces a result, and actual actions such as canceling an order or issuing a refund should be handled by your existing app's permissions and validation logic.
The response also includes usage information. In the official example, output_tokens shows 0, but you shouldn't read that as evidence that every request is processed free or unbilled. Check per-request cost and actual billing in your organization's usage and billing records.
You can also send images
The input is a string or an array of user messages, and a message body can contain text and inline images together. For example, you can send a customer's description and a photo of the damaged product as one input and have it judged. For images, you use data URLs rather than external URLs or file IDs, and up to 128 are allowed in the whole request.
{
"model": "gpt-6-luna",
"input": [
{
"role": "user",
"content": [
{ "type": "input_text", "text": "Is product damage visible in the photo?" },
{
"type": "input_image",
"image_url": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQ...",
"detail": "auto"
}
]
}
],
"questions": [
{
"type": "predicate",
"name": "visible_damage",
"instructions": "Is damage to the shipped item clearly visible in the image?"
}
]
}This input path doesn't accept audio or arbitrary files. According to the docs, the supported inputs are text and inline images in a user role, and audio, files, tool calls, non-user messages, and references to previous items are not supported. Check that images are in a data URL format the API allows.
How does it connect to a GPT-Live voice app?
The Decisions API doesn't listen to audio directly. GPT-Live handles the voice conversation, and your application passes the conversation transcript and the current state to Decisions to get a bounded choice back.
In OpenAI's guide, the browser example has the app send what was said together with the current page state and have it pick one of back, reload, or noop. The app checks that the response is still valid for the current state, performs the action, and returns the result to the Live session. If the user canceled or the state changed, it avoids acting on a stale choice. For cases that need a complex explanation or a plan, you can also add a branch that hands off to a separate model call.
In other words, GPT-Live handles natural real-time conversation, and the Decisions API evaluates the fixed options within the text context the app passes. The application controls permission checks and the actual action. You can see the whole flow in the official voice connection guide and the GPT-Live guide.
What the pricing page shows
The OpenAI API pricing page checked on October 7, 2026 lists GPT-6 Luna at $0.10 per million tokens for standard input, $0.01 for cached input, $0.125 for cache writes, and $0.50 for output. But the public pricing page does not list a Decisions API-specific rate as a separate item.
So you can't call the Luna prices above the confirmed Decisions-specific rate. Check the usage information in Decisions responses, and it is safer to reconcile the actual rate and caching conditions against your project's usage and billing records. Prices can change, so check the official API pricing page again when you adopt it.
Check ZDR, HIPAA, and data region separately
If you handle sensitive information, whether the API is available alone doesn't tell you whether your organization's data policy is met. OpenAI's docs describe retention settings and processing regions as separate items.
- HIPAA: Eligible use is limited to cases where you sign a BAA and Healthcare Addendum with OpenAI and meet the organization setup requirements. It is not an eligibility that applies automatically to every account.
- ZDR: You need to check the organization and project settings meant to reduce data retention, and the conditions per endpoint. Separate retention exceptions may apply to safety review related to images and files.
- Regional storage and regional inference: An indication that data can be stored in a certain region is different from inference being processed in that region. The current docs separate the Decisions regional inference listing into the US and Europe (EEA and Switzerland).
In OpenAI's data controls table, South Korea is listed as supporting regional storage (Yes) and not supporting regional processing (No). Regional inference for the Decisions API is listed as supported in the US and Europe (EEA and Switzerland), so you shouldn't confuse a setting that stores data in Korea with support for inference in Korea. Before you apply it, check your organization's contract, project settings, and the endpoint's latest limits together.
Related reading
- OpenAI Decisions API Launches: Two Weeks After Jev, GPT-6 Luna Picks an Option in 0.15 Seconds
- Perplexity Decisions API and pplx-decider-v1-27b
- Liquid AI d1 Released: Its First Decision Model and How to Use the API