OpenAI released the Decisions API into public beta on October 6, 2026 — a new endpoint that skips generated prose entirely and returns structured verdicts instead: a probability, a choice, or a score. It runs on the gpt-6-luna model, costs $0.10 per 1 million input tokens with zero charges for output or cache tokens, and OpenAI claims it answers about 10x faster than the Responses API. General availability is expected in the coming weeks.
That sounds niche. It isn’t — not if you run anything where an AI model has been grading, sorting, or routing text for you. Support-ticket triage, content moderation queues, lead scoring, fraud flags: all of these are currently built on the awkward trick of prompting a chat model and parsing JSON out of the reply. The Decisions API is OpenAI’s admission that this hack should be a first-class product.
What the Decisions API actually does
Every request hits POST /v1/decisions with a model (only gpt-6-luna for now — the low-latency GPT-6 tier that got a free-tier rollout earlier this month), an input (text, images, or both), and a set of named questions. Each question has one of three types that shape what comes back:
- Predicate — “Is this support ticket urgent?” returns a probability between 0 and 1.
- Choice — “Which queue gets this ticket: billing, technical, or sales?” returns one of your supplied options plus a confidence figure.
- Score — “Rate this bug’s severity against ordered levels (low, medium, high)” returns a probability-weighted score, which can land between levels.
Independent questions can share a single request. A decision that depends on an earlier answer needs a second call. Answers can also come back as refusals, so your code should check the answer type before reading the numbers — a detail Vercel’s write-up of the beta flagged explicitly.
One hard limit: image inputs must be inline base64 data URLs. Hosted image links and uploaded file IDs are refused on this endpoint, which keeps server-side fetch latency out of the loop but means you’re shipping bigger request payloads yourself.
The pricing math that matters
The headline number is $0.10 per 1M input tokens. That’s identical to the input price of gpt-6-luna itself through the Responses API — but the Decisions API charges $0 for output tokens, $0 for cache reads, and $0 for cache writes.
Why does that matter? Classification workloads have short answers, but not free ones. Through the standard API, you pay $0.50 per 1M output tokens for the structural boilerplate around every verdict. AI Weekly’s analysis of the beta estimated that billing output at zero cuts total cost to roughly one-fifth of standard Luna pricing for classification-style workloads.
That’s the honest economic pitch: not that input got cheaper, but that you stopped paying for the wrapper around every answer.
The speed claim — and what’s missing
OpenAI says Decisions runs “about 10x faster” than the Responses API. Its demo video showed a sub-100ms server response classifying loose user input into sales leads — not sped up, per the demo. One GitHub analysis of the beta put round-trip latency around ~150ms vs ~1.6s through the Responses API for the same model.
Here’s the caveat the coverage keeps repeating, and it matters: OpenAI has published no head-to-head accuracy numbers. The 10x figure measures speed against its own Responses API, not against any external vendor. Is a fast verdict as good a verdict? Neither the developer forum announcement nor the follow-on coverage publishes a comparison of /v1/decisions vs the same gpt-6-luna called through the Responses API on the same tasks.
If you’re evaluating this for production, treat the beta like any vendor benchmark: the latency is real enough to believe directionally, but the quality parity is the part you test yourself before you trust it.
What it replaces (and who feels the difference)
The honest way to read this product: OpenAI watched everyone build classification pipelines with JSON-schema prompt hacks on chat models and decided to productize the pattern. Three groups feel the difference first:
1. Support-ticket routing
If you run a small support operation — or you build automation for clients who do — ticket routing is the textbook case. Today: prompt the model, parse the JSON, retry when it hallucinates a queue name. With Decisions: define the choices, get a typed choice plus confidence, route on the confidence. The failure mode also gets cleaner — a refusal is an explicit signal instead of garbage text you have to validate.
2. Content moderation gates
OpenAI ships Zero Data Retention support, HIPAA eligibility, and US/EU data residency with the beta. That’s the compliance checkbox stack that makes Decisions a plausible drop-in for moderation flows in regulated spaces — exactly the flows that were previously duct-taped together on Chat Completions with structured outputs.
3. Damage and severity scoring
The score answer type is the interesting one nobody else ships quite like this: a weighted position on ordered levels. “How severe is this incident?” gets you a number like 1.4 on a 0-2 scale instead of a paragraph of reasoning you then re-parse. Incident triage, insurance intake, review queues — anywhere a human currently reads an AI paragraph and then picks a severity bucket.
OpenAI quietly cut its API tiers from five to three
Buried in the same announcement: OpenAI collapsed its five paid API tiers into three — Build, Launch, and Grow — with monthly usage limits of $500, $5K, and $200K. This is the kind of change that matters to small builders most: tier placement affects your rate limits and your access to new models, and if your monthly spend was anywhere near a boundary, your effective tier may have just moved.
The rival: TypeSafe’s Jev is cheaper
OpenAI isn’t alone here. TypeSafe’s Jev has been in early access since September 15, 2026, returning typed values with calibrated probabilities at $0.042 per 1M input tokens — about 2.4x cheaper than OpenAI’s $0.10. Jev supports up to 255 choices per question and reports 70–500ms end-to-end latency measured from the US West Coast.
OpenAI’s edge, per the coverage: image input (Jev is text-and-structured-state), compliance options (ZDR, HIPAA, residency), and the fact that it’s in open beta rather than early access. If you’re a small shop deciding between them, the honest math is: Jev wins on price, OpenAI wins on completeness — and neither has published the accuracy comparisons you’d actually want.
Who shouldn’t care yet
If you’re a freelancer or small business owner who uses ChatGPT as a tool, this announcement changes nothing about your workflow today. The Decisions API is a developer API — there’s no chat interface, no plugin, no “use it in ChatGPT” button. It matters to the people who build the automation you buy.
And even if you do build: the beta’s two real gaps are the unpublished accuracy numbers and the single-model limitation. General availability is “coming in the coming weeks,” and the product that GA’s — with benchmarks, more models, and real production SLAs — is the one worth building on.
What to do now
- If you build automations for clients: prototype one routing or scoring flow on the beta. It’s the cheapest way to learn the failure modes before GA.
- If you pay for classification APIs today: run your existing workload through Decisions for a week and compare the per-1M-token cost and your accuracy. The “one-fifth” estimate is directional, not a promise.
- If you just use AI tools: ignore this until GA. Watch for the accuracy story, not the price story — that number is the one that will decide whether this becomes standard plumbing.
OpenAI’s long game here is obvious: every developer who currently wrestles JSON out of a chat model is a developer whose workload OpenAI can now price at $0.10/1M and serve at ~150ms. Whether the verdicts are worth trusting is the part the beta still has to prove.
Frequently Asked Questions
When did the OpenAI Decisions API launch?
OpenAI introduced it at DevDay on September 29, 2026 as a limited preview, then opened public beta on October 6, 2026. General availability is expected in the coming weeks, with no firm date published.
How much does the Decisions API cost?
$0.10 per 1 million input tokens, with no charges for output tokens, cache reads, or cache writes. Regional-processing premiums and higher input rates for long contexts can still apply.
What model powers the Decisions API?
Only gpt-6-luna for now, a low-latency tier of OpenAI’s GPT-6 family. No open weights and no self-hosting — it’s hosted exclusively by OpenAI.
How is the Decisions API different from Structured Outputs on the Responses API?
Instead of generating text that you parse into JSON, Decisions returns typed answers directly (probability, choice with confidence, or score) — and OpenAI claims it’s about 10x faster. Accuracy parity hasn’t been independently published yet.
Can the Decisions API process images?
Yes, but images must be inline base64 data URLs — hosted image links and uploaded file IDs are refused.
Is the Decisions API HIPAA-compliant?
It ships with Zero Data Retention support, HIPAA eligibility, and US/EU data residency options, making it suitable for regulated moderation and gating flows.
Sources: OpenAI launches Decisions API public beta on GPT-6 Luna; Decisions API: GPT-6 Luna Beta, Pricing and Limits; Decisions API hits public beta with 10x faster typed answers; Related: Anthropic’s cloud agent switch for business workflows.