Updated 16 October 2026. OpenAI added native Decisions support to GPT-Live on 15 October; the API is still in public beta, with general availability expected in the coming weeks.
The OpenAI Decisions API is a dedicated endpoint, POST /v1/decisions, that answers questions you define with typed results instead of text. You send input and a list of questions, and for each one it returns a probability, a chosen option or a score that your code can act on. OpenAI describes it for classifying content, routing requests and choosing an agent's next action.
As of 16 October 2026, it is in public beta, runs only on gpt-6-luna, and costs $0.10 per 1M input tokens with no charge for output. Below: the status and price, how a request works, a first Python example, how it differs from a chat model and from Jev, the known limits, and four business uses.
OpenAI Decisions API at a glance
| Item | As of 16 October 2026 |
|---|---|
| Endpoint | POST /v1/decisions |
| Model | gpt-6-luna only |
| Status | Public beta since 6 October 2026; GA expected in the coming weeks, no date |
| Price | $0.10 per 1M input tokens; no charge for output, cache reads or cache writes |
| Question types | predicate, choice, score |
| Input | Text, or user messages with text and base64 image parts |
| Data controls | Zero Data Retention and HIPAA for eligible customers; data residency in the US and Europe (EEA plus Switzerland) |
Release date and beta status
- 29 September 2026: InfoQ reported that OpenAI announced the Decisions API at DevDay as a limited preview.
- 6 October 2026: OpenAI's API changelog lists the beta release with gpt-6-luna.
- 15 October 2026: the changelog adds native Decisions support inside GPT-Live, which can call Decisions directly or trigger decisions from transcript updates.
- General availability: expected in the coming weeks, according to OpenAI's guide, with no date given.
Beta details can change, so log every request and answer, and recheck the guide before launch.
OpenAI Decisions API pricing
As of 16 October 2026, the guide lists one rate: $0.10 per 1M input tokens, with no charge for output tokens, cache reads or cache writes. Two gpt-6-luna rules still apply: prompts over 272K input tokens pay 2x the input rate, and regional processing adds 10%.
A hypothetical example: a business routes 100,000 support messages a month at about 500 input tokens each, instructions and choices included. That is 50M input tokens, or about $5 a month at list price. Building the workflow, labeling test data and handling unclear cases will cost far more than the model. Our LLM API costs guide shows how to estimate a full bill.
How a Decisions API request works, step by step
- Update your SDK. Minimum versions: Python 3.26.0, JavaScript 7.30.0, Go 3.73.0, Ruby 0.101.0, Java 4.78.0. In Python the call is
client.decisions.create. - Prepare the input: a text string, or user messages that mix text and image parts.
- Write the questions. Each gets a unique
name, atypeandinstructions. Choice questions listchoices, each avalueand adescription. Score questions list orderedlevels, each alabeland adescription. - Send one request to
/v1/decisionswithmodelset togpt-6-luna. Independent questions, even of different types, can share it. Decisions that depend on each other need separate requests. - Read the
answersarray. Each answer carries its question'snameand atype. - Check for refusals. Any answer can come back as type
refusal, so route those to a person. - Apply thresholds in your code to decide what happens next.
A Playground lets you test questions and inputs before you write code.
The three question types
| Type | Use it for | What comes back |
|---|---|---|
predicate | A yes-or-no check, such as "Is this a refund request?" | A probability from 0 to 1 |
choice | Picking one option, such as a team or a category | The choice, probabilities and a confidence |
score | Placing an item on an ordered scale, such as low to high priority | A score, probabilities and a confidence |
Score levels are numbered from 0, and the score is a probability-weighted average, so it can fall between levels: on a three-level scale, 1.4 is a normal answer.
First working example in Python
This example scores and routes a sales inquiry with one question of each type. It uses the fields documented in OpenAI's guide; the text and wording are ours. Compare it with the official samples before you ship, since the API is in beta.
from openai import OpenAI
client = OpenAI()
result = client.decisions.create(
model="gpt-6-luna",
input="Website form: We run three dental clinics and want an AI receptionist live before January.",
questions=[
{
"name": "fit",
"type": "score",
"instructions": "How well does this inquiry fit a studio that builds custom AI tools?",
"levels": [
{"label": "poor", "description": "Wants something we do not build"},
{"label": "possible", "description": "Related need, unclear scope"},
{"label": "strong", "description": "Clear AI project and need"},
],
},
{
"name": "route",
"type": "choice",
"instructions": "Who should follow up on this message?",
"choices": [
{"value": "sales", "description": "A new project inquiry"},
{"value": "support", "description": "An existing client needing help"},
{"value": "other", "description": "Spam or anything else"},
],
},
{
"name": "has_deadline",
"type": "predicate",
"instructions": "Does the message mention a deadline?",
},
],
)
for answer in result.answers:
if answer.type == "refusal":
print(answer.name, "refused, send to a person")
elif answer.type == "score":
print(answer.name, answer.score, answer.confidence)
elif answer.type == "choice":
print(answer.name, answer.choice, answer.confidence)
elif answer.type == "predicate":
print(answer.name, answer.probability)
- One call, three questions: they are independent, so they share a request.
- An "other" choice: OpenAI's guide suggests a fallback like this when your categories do not cover every input, with those results sent to a review queue.
- Refusals first: never assume every answer holds a choice or a score.
To check an image, send input as a user message with a text part and an image part. Images must be inline base64 data URLs; hosted URLs and file_id inputs are not supported. The guide also has JavaScript, Go, Java, Ruby and cURL versions of its samples.
Decisions API vs a chat model
A chat model, called through the Responses API, writes text. The Decisions API returns labels and numbers.
| Decisions API | Chat model (Responses API) | |
|---|---|---|
| Output | Typed answers with probabilities | Text, or JSON when you ask for it |
| Speed | OpenAI says about 10x faster than the Responses API | Baseline |
| Output tokens | Not charged | Billed at the model's output rate |
| Best for | Classify, route, score, yes-or-no gates | Writing, summarizing, explaining, multi-step work |
OpenAI publishes no benchmark for its 10x speed claim. Firecrawl reported that a DevDay slide showed about 150 ms for Decisions against 1.6 seconds for a normal Luna call. Measure from your own servers before you promise a response time.
The guide also says when to use something else: Structured Outputs for objects that follow your own JSON schema, and function calling for tool arguments. To write a reply, you still need a chat model. Many systems use both: a decision step routes the message, then a chat model drafts the answer.
Decisions API vs Jev and Microsoft-Decision-1
OpenAI is not alone. TypeSafe AI launched Jev on 15 September, before OpenAI's preview, and Microsoft announced Microsoft-Decision-1 on 9 October. Both also return typed answers with probabilities.
| OpenAI Decisions API | Jev | Microsoft-Decision-1 | |
|---|---|---|---|
| Input price per 1M tokens | $0.10 | $0.042 | $0.042 |
| Output | Not charged | Free | Free |
| Endpoint | /v1/decisions | api.typesafe.ai/v1/systemone | Your Foundry resource, ending in /providers/microsoft/v1/systemone |
| Yes-or-no type | predicate | noul | noul |
| Images | Yes, base64 only | Experimental, opt-in | Not documented |
| Where | OpenAI API | TypeSafe API | Microsoft Foundry, OpenRouter |
Prices are as of 16 October 2026, from each vendor's pages. OpenAI costs more than twice as much per input token but documents image input today and fits the OpenAI stack, including GPT-Live. Our Microsoft-Decision-1 vs Jev vs OpenAI comparison covers Jev 1.14 and more, our Jev guide explains Jev itself, and our roundup of open-source Jev alternatives covers models you can host yourself.
Known limits and unknowns
- Beta: fields, limits and prices can change before GA.
- One model: only gpt-6-luna, so there is no larger model for harder questions.
- No published limits: as of 16 October 2026, the guide gives no limits on questions, choices, levels, tokens or images, and no rate limits for
/v1/decisions. - Unconfirmed image cap: Mixed News reported a limit of 128 image parts per request, which is not in OpenAI's guide. It also noted that on 6 October the gpt-6-luna endpoint table did not list
/v1/decisions. - Images: base64 only, with no hosted URLs or
file_idinputs. - Old explainers: articles from the preview say no schema was published. That is out of date; the guide now documents the fields.
Red Hat adds a wider caution. Its 2 October tests of decision models, including Jev 1.13.0, against small classifiers and LLM judges on prompt-injection and content-safety tasks found that the decision models did not reliably beat them. On prompt injection, a small DeBERTa classifier scored 89.01% at 54 ms, against 86.35% at 348 ms for Jev. Test any decision API on your own data before you trust it.
Business uses: lead scoring, routing, approvals and fraud flags
The pattern is the same each time: the model scores, your code decides, and a person handles unclear cases. These examples are hypothetical. Thresholds would be tuned on the business's own labeled examples, weighing the cost of false positives against false negatives, as OpenAI's guide advises.
Lead scoring
Score each inquiry for fit and ask whether it mentions a budget or deadline. Leads above the threshold reach sales the same day; the rest get a standard reply. An AI lead qualification assistant wraps this in a full reply flow.
Ticket and email routing
A choice question picks the team, with "other" as the fallback, and a predicate flags urgent messages. Low-confidence results go to a shared queue. Our AI customer support guide covers the rest of the setup.
Approvals
Before an expense claim, discount or agent action goes through, ask yes-or-no questions against your policy: does it fit an allowed category, does the receipt image match the claim, is a reason given? Approve automatically only when every probability clears its threshold. Keep arithmetic, such as totals and limits, in code.
Fraud and risk flags
For refunds or orders, include the order history and ask whether the stated problem matches it, or score the risk from low to high. Let a high score trigger a review, not a block: flagging an honest customer and missing a bad refund carry different costs.
The same approach can choose an agent's next step; see AI agents for business. For turning probabilities into actions, our Jev confidence scores article applies to any decision API.
If you want a decision layer like this built and tested on your own data, talk to us. Apex Logic builds AI features on fixed quotes, and you own all the code.
OpenAI Decisions API FAQ
What is the OpenAI Decisions API?
It is an OpenAI endpoint, POST /v1/decisions, that answers questions you define with typed results instead of text. You send input plus predicate, choice or score questions, and get back a probability, a chosen option or a score for each. It runs only on gpt-6-luna and suits classifying, routing and agent decisions.
How much does the OpenAI Decisions API cost?
As of 16 October 2026, it costs $0.10 per 1M input tokens, with no charge for output tokens, cache reads or cache writes. For gpt-6-luna, regional processing adds 10%, and prompts over 272K input tokens pay twice the input rate. Prices may change before general availability.
Is the Decisions API generally available?
Not yet. It entered public beta on 6 October 2026, after a limited preview at DevDay on 29 September that InfoQ reported. OpenAI's guide says it expects general availability in the coming weeks but gives no date. You can build on it now, but log requests and recheck the docs before launch.
Can the Decisions API read images?
Yes. Send user messages that mix text and image parts, with each image as an inline base64 data URL. Hosted image URLs and file_id inputs are not supported. OpenAI publishes no cap on images per request; Mixed News reported a limit of 128 image parts, but that figure is not in OpenAI's guide.
Is the Decisions API better than Jev?
It depends on the job. Jev lists $0.042 per 1M input tokens against OpenAI's $0.10, and neither charges for output. OpenAI documents image input today and suits teams already on OpenAI; Jev's image input is experimental. Vendor speed and accuracy figures come from different tests, so compare both on your own labeled examples.
When should I not use the Decisions API?
Skip it when you need written output, such as a reply or summary; use a chat model. OpenAI points to Structured Outputs for your own JSON schemas and to function calling for tool arguments. Dependent decisions need separate requests, and for high-stakes calls it should filter cases for a person, not decide alone.
Loading comments...