A lot of AI interactions inside production software are not creating new text, but instead answering a very specific question: is this ticket about billing, does this photo show damage, should I escalate or not.
Asking a chat model to do that is wasteful in terms of tokens both ways: you pay for the model to generate an answer, and then you have to parse that generated natural language text into something your software can actually execute branching logic on.
The OpenAI Decisions API is designed to directly answer these types of questions. Announced at DevDay on September 29, 2026 and available in public beta as of October 6, 2026, the Decisions API takes input text and a set of options and returns typed probabilities, selected options and scores.
This article covers how the Decisions API works, its pricing, the type of outputs it supports, provides an example and compares it to using a chat model.
Key Highlights
- What it is: a dedicated endpoint (POST /v1/decisions) that returns typed answers instead of generated text.
- Model: gpt-6-luna is the only supported model during the beta.
- Outputs: a predicate (probability a condition is true), a choice (one of your options, with probabilities and confidence), or a score (a probability-weighted position on an ordered rubric).
- Inputs: text, images, or both. Images must be inline base64 data URLs.
- Pricing: $0.10 per 1M input tokens. No output-token, cache-read or cache-write charges.
- Speed: OpenAI says it is about 10x faster than the Responses API for this kind of job. That is a vendor claim, so benchmark it on your own traffic.
- Status: public beta, with GA expected in the coming weeks according to OpenAI's docs.
- Best fit: classification, routing, moderation and prioritization. Not for writing text, custom JSON schemas or tool calls.
What Is the OpenAI Decisions API?
The OpenAI Decisions API is an endpoint that evaluates text, images or both and returns typed answers: whether a condition is true, which option fits, or how an input scores against a rubric.
It is powered by GPT-6 Luna, OpenAI's low-cost model tier, but never outputs prose. Your application gets back numbers and values it can branch on directly.
OpenAI first unveiled it at DevDay as a limited preview, and launched the public beta on October 6, 2026. As it's a beta, expect request and response details to evolve until GA.
How Is It Different From Structured Outputs?
Structured Outputs create a model that outputs an object that matches a JSON schema you provide, such as extracted fields or a written explanation. The Decisions API from OpenAI does not generate.
It chooses from answer types defined by OpenAI (predicate, choice, score) and attaches probability information.
The guidance from OpenAI is clear: use Decisions when you need one of these answer types, Structured Outputs with the Responses API when you need your own object, and function calling when the model must request a tool call with arguments.
How the OpenAI Decisions API Works
Every request has three fields.
| Field | Purpose |
|---|---|
| model | The evaluating model. Only gpt-6-luna is supported today. |
| input | Shared evidence for all questions: a text string, or user messages containing text and images. |
| questions | What to evaluate: each question's type, instructions, and any allowed choices or score levels. |
The answer contains an answers array. Give each question a uniquely named, the API echoes it back, so you can associate answers with questions. Also, a question could return a refusal answer, so your code should have a branch for that.
Independent questions could share a single input in a single request. For example, you could ask to check a product photo for damage and classify the category in one request. If a question depends on a previous answer, send a separate request.
OpenAI Decisions API Outputs: Predicate, Choice and Score
| Question type | Use it to | What you get back |
|---|---|---|
| predicate | Check a condition, such as visible damage or passage relevance | probability from 0 to 1 that the condition is true |
| choice | Pick one option, such as a department or content category | choice (one of your values), per-option probabilities, and confidence |
| score | Rate against ordered levels, such as severity | score (a probability-weighted average of level indices), per-level probabilities, and confidence |
Predicate
A predicate answers a yes/no condition as a probability. In the example used by OpenAI to illustrate the use of this tool, a product photo checked for a crack, tear or dent would return 0.92. You choose based on how much the loss due to missed defect is higher than the loss due to a false alarm.
Choice
A choice question asks users to pick one of the values you provide. For example, OpenAI's example asks for a routing of the message "I was charged twice for my order" across billing, technical, shipping and other, and returns billing with a 0.95 probability and 0.93 confidence. You should always include a fallback such as other to capture inputs that don't match any of your options.
Score
A score question evaluates an input against a set of ordered levels, indexed at 0. If the probability spans across cosmetic, workaround available and fully-blocked categories, and is 0.1, 0.7 and 0.2, respectively, the resulting score is 1.1. As it is a weighted average, it falls between levels and can be seen as a continuous signal of priority level. Should you need to pick a single category, use choice instead.
How to Read Confidence
Choice and score answers return a probability distribution as well as a separate confidence field. OpenAI recommends setting thresholds on these answers based on labeled examples from your application, weighed against the cost of false positives and false negatives. Do not ship a default 0.5 and hope.
OpenAI Decisions API Pricing
OpenAI Decisions API pricing is simple on paper. With gpt-6-luna, input costs $0.10 per 1M tokens, and you pay only for input tokens. There are no cache-read, cache-write or output-token charges. Regional processing premiums and long-context input multipliers still apply, and these rates cover /v1/decisions only.
| Item | Decisions API (/v1/decisions) | Luna via Responses API (standard tier) |
|---|---|---|
| Input | $0.10 / 1M tokens | $0.10 / 1M tokens |
| Output | Not billed | $0.50 / 1M tokens |
| Cached input | Not billed; no caching available today | $0.01 / 1M tokens |
| Long context | Multipliers apply | Prompts over 272K input tokens move to $0.20 in / $0.75 out |
The Responses API figures come from OpenAI's published pricing as reported by third-party trackers, so confirm them on OpenAI's pricing page before budgeting.
A Worked Cost Example
Here is illustrative arithmetic from list prices, not a benchmark. Say you run 1M classifications a month, each with 1,200 input tokens: 400 variable tokens (the ticket) and 800 stable tokens (instructions and option descriptions).
- Decisions API: 1.2B input tokens x $0.10/M = $120.
- Luna on Responses API with caching: 800M cached tokens x 0.01/M(8) + 400M uncached x 0.10/M(40) + about 40 output tokens per call, 40M x 0.50/M(20) = $68, assuming near-full cache hits.
So the OpenAI Decisions API is not automatically cheaper. For prompt-heavy classification, the lack of caching can make it the more expensive option, a point developers raised in OpenAI's community forum within a day of launch. Your case for it rests on latency and simpler code. Run the numbers on your own prompt shape.
On data handling, OpenAI says the endpoint supports Zero Data Retention and HIPAA use for eligible customers, with data residency and regional processing in the United States and Europe (EEA and Switzerland). Eligibility depends on your agreements, so check OpenAI's data controls page.
If you are modeling this against a real workload, RejoiceHub's AI consulting team can help you cost the decision layer against your actual traffic before you commit.
OpenAI Decisions API vs Responses API
| Dimension | OpenAI Decisions API | Responses API (Luna) |
|---|---|---|
| Output | Typed answers with probabilities | Generated text, schema-bound objects, tool calls |
| Speed | OpenAI claims about 10x faster | Baseline |
| Billing | Input tokens only | Input, output and cached input |
| Prompt caching | Not available today | Available |
| Custom JSON schema | No | Yes, via Structured Outputs |
| Tool calling | No | Yes |
| Explanations | No, answers only | Yes, if you ask for them |
| Status | Public beta | Established API |
Use the Decisions API when your code would otherwise parse the model's reply into one of N values or a number: routing, moderation, severity scoring, relevance gating, next-step selection in an agent loop.
Use the Responses API when a human reads the output, you need custom fields, you need tool calls, or you need the model to explain itself.
The two also combine well. A common pattern is a fast decision gate in front of an agent: the Decisions API picks the lane, and a full chat model only runs for the cases that need reasoning or writing.
OpenAI Decisions API How to Use: Step by Step
- Get access and experiment first. Try questions and inputs in OpenAI's Playground before writing code.
- Update your SDK. OpenAI lists Python 3.26.0, JavaScript 7.30.0, Go 3.73.0, Ruby 0.101.0 and Java 4.78.0 as the minimum versions for the documented examples.
- Write questions around observable criteria. Separate concerns into separate questions, give choices distinct meanings, and make adjacent score levels distinguishable.
- Call decisions.create with model, input and questions.
- Handle refusals first, then branch on the answer type.
- Set thresholds from labeled data, and send low-confidence or other results to human review.
- Log probabilities alongside decisions so you can recalibrate as traffic change.
Limits to Plan For Before You Ship
- It is a beta. OpenAI expects GA in the coming weeks. Pin SDK versions and expect schema changes.
- One model. gpt-6-luna is the only supported model, so you cannot trade up for accuracy on hard questions.
- No caching. Long, stable instruction blocks are billed in full on every call.
- Images are base64 only. Hosted HTTP or HTTPS image URLs and file_id inputs are not supported.
- No explanations. You get answers and probabilities, not reasoning. Log inputs and outputs so you can audit decisions later.
- Early community findings on choice questions. One developer reported in OpenAI's forum that a choice question on a 70% biased coin concentrated about 98% of answers on heads over 1,000 trials, while the equivalent predicate matched roughly 70%. The same thread reported that option order changed the probabilities. This is a single unreviewed test, but it is cheap to replicate on your data. If you need calibrated probabilities, consider one predicate per option and test with shuffled option order.
- Latency claims are OpenAI's. Measure p50 and p95 on your own network and payloads before promising an SLA.
OpenAI Decisions API Documentation: Where to Look
The documentation is available on developers.openai.com/api/docs/guides/decisions. It covers the decision request fields, the three types of questions supported, and the pricing and data controls.
The same documentation links to the playground and instructions for connecting voice to decisions. If you're working in Vercel's AI SDK, their documentation describes an experimental_decide interface that uses openai.decisionModel('gpt-6-luna'). Note that these are both rapidly evolving during the beta period, so check back often.
Conclusion
The OpenAI Decisions API is a narrow tool that focuses on reducing the overhead of your many small classification and routing calls by exposing them as typed, branch-ready responses. Its primary wins are reduced latency and simpler code. The value proposition is contextual (depends on your prompt shape) and you should test the API on a small high-volume routing or moderation task before considering a migration of any critical production workflows. Consider accuracy, latency, and cost relative to your current chat-model based implementation as your main metrics for evaluating such a migration.
Frequently Asked Questions
What is the OpenAI Decisions API?
The OpenAI Decisions API is an endpoint that reads text, images, or both and returns typed answers instead of prose. You get a simple true or false probability, a chosen option, or a score your code can branch on directly.
How much does the OpenAI Decisions API cost?
It costs $0.10 per 1M input tokens with the gpt-6-luna model. You pay only for input, so there are no output, cache-read, or cache-write charges. Regional processing premiums and long-context input multipliers can still apply to your total monthly bill.
What models does the Decisions API support?
Only gpt-6-luna is the supported model during the public beta. It is OpenAI’s low-cost model tier, so you cannot trade up to a bigger, more accurate model for harder questions right now. OpenAI expects general availability in the coming weeks.
Is the OpenAI Decisions API faster than the Responses API?
Yes, OpenAI says it is about 10x faster than the Responses API for classification-style jobs. That is a vendor claim, so test p50 and p95 latency on your own real traffic and payloads before promising anyone a firm speed target.
What types of answers does the Decisions API return?
It returns three types: predicate, choice, and score. A predicate gives a probability from 0 to 1 that a condition is true. A choice picks one of your options with probabilities for each. A score rates input against ordered levels.