If your app asks an AI model a yes-or-no question, you probably know the pain: you ask for a clean answer, the model writes a paragraph, and somewhere in your code a regular expression tries to extract the word “yes” from “I believe this does constitute a refund request.” It works on Monday. By Friday the model gets chatty, the regex misses, and a support ticket lands in the wrong queue. The OpenAI Decisions API, which entered public beta on October 6, 2026, exists to end that fragile dance. Instead of prose, it returns typed verdicts: a probability, a choice, or a score. Here are the facts you need to know.
What Is the OpenAI Decisions API?
The OpenAI Decisions API is a dedicated endpoint — POST /v1/decisions — that returns structured judgments instead of generated text. You send it evidence (your input) plus one or more questions, and it answers each question in a fixed, machine-readable shape. The response carries an answers array keyed by the names you gave your questions. Because it generates no text, there are no output tokens to pay for and nothing to parse on your side. OpenAI also ships a free Playground so you can experiment with the endpoint before writing any code. It is worth understanding alongside the models that power it, which is why our GPT-6 Sol and Luna facts guide makes useful background reading — Luna is the only model the Decisions API can use during the beta period.
The 3 Question Types the Decisions Endpoint Supports
Every decision you request falls into one of three types, each with a precisely defined answer shape.
1. Predicate: a yes-or-no condition with a probability
A predicate evaluates whether a single condition holds and returns a probability between 0 and 1. OpenAI’s own example asks whether a product photo shows visible damage and gets back 0.92. Your code then compares that number against a threshold you set — for example, auto-approve above 0.9, escalate between 0.6 and 0.9, and hand to a human below 0.6. The probability is the point: a bare label cannot drive policy, but a probability can.
2. Choice: pick one option from a fixed list
A choice question gives the API a fixed set of candidate answers and returns the winning option, the per-option probabilities, and a confidence value. Ask which department owns a support ticket, and the API might route “I was charged twice” to billing with 0.95 probability and 0.93 confidence. Developers are advised to include an “other” fallback so uncovered cases land in a human review queue instead of being forced into a wrong bucket.
3. Score: rate against an ordered rubric
A score question rates input against ordered levels you define, indexed from 0. The API returns a probability-weighted average of the level indices plus a confidence figure. In OpenAI’s severity example, level probabilities of 0.1, 0.7, and 0.2 produce a score of 1.1 — a value sitting between “Workaround available” and “Fully blocked.” It is a neat fit for incident severity, content risk, or any rating task where the distance between levels matters.
7 Facts You Must Know About the OpenAI Decisions API
Fact 1: It launched at DevDay and hit public beta on October 6, 2026
The endpoint first appeared as a limited preview announced at OpenAI’s DevDay in late September 2026, then graduated to public beta on October 6. OpenAI says general availability will follow “in the coming weeks” — an expectation, not a date, so treat any timeline as provisional.
Fact 2: It runs exclusively on GPT-6 Luna during beta
As of mid-October, gpt-6-luna is the only supported model. You cannot point the endpoint at GPT-6 Sol or any earlier model, and access through a third-party Luna interface does not establish compatibility with the dedicated endpoint. Luna was designed for fast, cheap classification-style work, which is exactly what this API does.
Fact 3: OpenAI claims it is up to 10x faster than the Responses API
OpenAI’s developer announcement says the Decisions API makes decisions up to 10 times faster than GPT-6 Luna through the Responses API, and DevDay coverage put a decision at roughly 150 milliseconds versus about 1.6 seconds for a regular Luna call. That is the company’s claim, and it has not been independently verified — OpenAI has not published accuracy or calibration data for the endpoint. The honest read: the speed advantage is plausible because no text is generated, but wait for independent benchmarks before you re-architect a latency-critical pipeline around it.
Fact 4: Pricing is input-only and startlingly cheap
With gpt-6-luna, input costs $0.10 per 1 million tokens, and there are zero output-token, cache-read, or cache-write charges — because there are no output tokens. Classifying a 500-token support message costs about $0.00005. Caveats: regional-processing premiums and long-context multipliers still apply, and Luna’s model card prices prompts above 272K tokens at twice the input rate.
Fact 5: Refusals are a first-class answer type
A refusal is a separate answer type — not a low score and not your fallback category. That design detail matters for moderation and safety pipelines: you can distinguish “the model declined to decide” from “the model decided the content is safe,” which are very different outcomes for your error handling.
Fact 6: It is not a replacement for Structured Outputs or function calling
OpenAI draws a clear line. Use Decisions for probabilities, choices, and scores. Use Structured Outputs when you need to fill your own JSON schema or get written explanations. Use function calling when a model must request a tool call with arguments. In other words, Decisions tells you how sure the model is; Structured Outputs guarantees the shape of the answer; function calling triggers actions.
Fact 7: Compliance and residency options already exist in beta
Eligible customers can use Zero Data Retention and HIPAA arrangements, and the API lists US and European regional processing (the EEA plus Switzerland). The minimum SDK versions are Python 3.26.0, JavaScript 7.30.0, Go 3.73.0, Ruby 0.101.0, and Java 4.78.0 — check your project’s SDK before deployment, and confirm model access, billing status, and rate limits with a small test request first.
How the Decisions API Pricing Compares
At $0.10 per million input tokens, Decisions pricing sits at the bargain end of OpenAI’s API lineup — the same per-token rate OpenAI charges for its cheapest classification workloads. The real savings come from the absent output tokens: a traditional Responses API call that returns a paragraph of analysis charges you for every token of that paragraph, while the Decisions endpoint charges only for the input. For high-volume classification — ticket routing, content moderation, fraud signals — the per-decision cost can drop to fractions of a cent, which is precisely the workload the endpoint was built for.
Decisions vs Structured Outputs vs Function Calling
It helps to keep the three tools in one mental frame. Structured Outputs guarantees that a model’s answer follows your schema, but the model still writes prose inside that schema, and you still pay for those tokens. Function calling lets the model request a tool invocation with arguments — powerful, but designed for action, not verdicts. The Decisions API does something narrower: it returns a typed judgment — probability, choice, or score — with no prose at all. If you previously hacked classification out of the Chat or Responses API with JSON mode plus a regex, Decisions is the purpose-built replacement. That said, it cannot chain: dependent decisions need separate requests, and multiple questions may share one input only when they are independent.
Who Should Use It — and Who Should Wait
The best fits are teams already doing classification with language models: support-ticket routing, product-photo damage inspection, bug-severity triage, content moderation queues, and agentic systems that need a cheap “what next?” verdict before choosing an action. The Live API even lets decisions drive actions via client delegation. Who should wait? Anyone needing production stability guarantees — the endpoint is in public beta, backed by a single model, with no published benchmark data. If you adopt it now, calibrate your thresholds on your own labeled data rather than trusting raw probabilities out of the box, because those probabilities are estimates, not calibrated truth.
Limitations Worth Knowing Before You Build
Four honest caveats. First, it is beta-only, with beta-grade stability expectations. Second, images must be sent as inline base64 — there is no URL-based image input. Third, you cannot chain decisions: if question B depends on question A’s answer, you must make two sequential requests. Fourth, the speed claim is unverified and the calibration data unpublished, so measure latency and accuracy on your own workload before committing. None of these are deal-breakers, but they are the difference between a smooth pilot and a surprise.
Frequently Asked Questions
What is the OpenAI Decisions API?
It is a dedicated OpenAI endpoint (POST /v1/decisions) that returns typed verdicts — probabilities, choices, or scores — instead of generated text. It entered public beta on October 6, 2026, powered exclusively by GPT-6 Luna during the beta period.
How much does the OpenAI Decisions API cost?
Input costs $0.10 per 1 million tokens with gpt-6-luna, and there are no output-token, cache-read, or cache-write charges. Regional-processing premiums and long-context multipliers still apply, and prompts above 272K tokens are billed at twice the input rate.
How is it different from Structured Outputs?
Structured Outputs guarantees the shape of a model’s prose answer; the Decisions API skips prose entirely and returns only a probability, a choice, or a score, with a confidence value. Use Decisions when the verdict itself is what your code acts on.
Can the Decisions API write explanations?
No. It generates no text at all. If you need written explanations alongside a verdict, use Structured Outputs or the Responses API instead — or call Decisions for the verdict and a second endpoint for the explanation.
The Bottom Line
The OpenAI Decisions API is a small, sharp tool: a purpose-built endpoint for the enormous class of AI tasks that are really just classification in disguise. The public beta pricing is aggressive, the input-only billing is genuinely novel, and the three question types cover most routing, scoring, and triage workloads. Keep the honest caveats in view — beta status, one model, unverified speed claims, uncalibrated probabilities — and it is absolutely worth a weekend pilot. For more context on the models behind it, see our GPT-6 Sol and Luna guide and how OpenAI is reshaping the chat experience in our GPT-6 Intelligent UI breakdown. And if you are building with the API, the official documentation lives at OpenAI.