Last updated: October 9, 2026
OpenAI's Decisions API is an endpoint that answers a fixed question about text or images with a probability, a choice from your list, or a score, instead of generated text; it entered public beta on October 6, 2026, runs only on GPT-6 Luna, and costs $0.10 per million input tokens with no output charge.
TL;DR
Pick Jev for text-only classifiers, routers and guardrails. In the one independent test so far, it matched the Decisions API on accuracy at about half the cost per call, with a much shorter slow tail.
Pick the Decisions API when the input is a screenshot, scan or photo, or when you need OpenAI's zero data retention, HIPAA or EU data residency. Jev reads text only.
Price: $0.10 per million input tokens for Decisions against $0.042 for Jev. Neither charges for output.
Status: public beta, with general availability expected "in the coming weeks," per OpenAI.
OpenAI first showed the Decisions API at DevDay on September 29 as a limited preview (FOMA covered it that week). A week later the changelog opened it to everyone. It's the same shape as TypeSafe's Jev, which shipped two weeks before DevDay: you write the question and the allowed answers, the model picks. No blank page.
What is the OpenAI Decisions API?
You send POST /v1/decisions with an input (text, images or both) and a list of questions. Each question has one of three types (OpenAI's guide):
Predicate: "is this true?" Returns a probability from 0 to 1.
Choice: "which of these?" Returns one of the values you supplied, plus the probabilities and a confidence field.
Score: "how bad, on this scale?" Returns a probability-weighted average of the levels, so it can land between them.1
You can ask several independent questions about one input in one request. If question two depends on the answer to question one, that's two requests. An answer can also come back as a refusal, so your code needs that branch.
OpenAI says it is about 10x faster than asking GPT-6 Luna the same thing through the Responses API. That's a comparison with OpenAI's own chat endpoint, not with other decision models.2
OpenAI Decisions API pricing and availability
Here's the price sheet, as of October 9, 2026:
Decisions API (gpt-6-luna): $0.10 per million input tokens. No output, cache-read or cache-write charges (guide). Regional processing and long-context multipliers apply.3
GPT-6 Luna through the Responses API: $0.10 input and $0.50 output per million tokens (model page).
TypeSafe Jev: $0.042 per million input tokens, output free (TypeSafe's model docs).
Status: Decisions is a public beta. Jev launched on September 15.
Inputs: Decisions takes text and images. Jev takes text only.4
Data controls: Decisions supports zero data retention and HIPAA for eligible customers, with data residency in the US and Europe.
OpenAI Decisions API cost per call
The sticker is 2.4x Jev per token, but the bill depends on how many tokens each vendor counts. The only head-to-head so far, a 9,000-call test by agent.nexus published October 7, measured $0.22 per 1,000 calls on Decisions against $0.11 on Jev. So about 2x.5
The catch is per-question overhead. In that test, each extra yes-or-no question added about 144 billed tokens on Decisions and almost nothing on Jev. One question per call costs 1.5x Jev. Eight questions costs 6.8x.6 If your design packs many checks into one call, which is the point of these models, price it with your real question count.
Is the Decisions API on Azure or Bedrock?
Not that I could find. The guide documents only OpenAI's own endpoint. A Microsoft moderator said on October 7 that there is no confirmed date for Microsoft Foundry (Microsoft Q&A). Vercel's AI Gateway did add it on October 7, under the model ID openai/gpt-6-luna-decisions (Vercel changelog).
OpenAI Decisions API vs Jev
Same job, different trade-offs. Ties on the average call, loses on the slow ones. In the agent.nexus test, on eight real text checks:
Accuracy: a tie. 233 errors for Decisions and 221 for Jev on the same 2,155 labelled cases, inside each other's error bars.
Typical speed: a tie. Median 268 ms against 269 ms.
Slow calls: Jev. At the 99th percentile, Decisions took 1,469 ms against Jev's 526 ms.7
Cost per call: Jev, at about half the price.
Two big asterisks. The testers run Jev in their own product and say so, and they tuned thresholds on Jev's outputs. And they tested text only. Images are where Decisions has no Jev rival at all: "is this a login page," "is there a card number in this upload," "is this scan signed." Jev can't take the input.
Jev also has more neighbours now. Cloudflare's open-weight Clef models do the same job and return a probability instead of a paragraph (FOMA's October 8 issue).
How to try the Decisions API
Update your SDK. The guide lists Python 3.26.0 and JavaScript 7.30.0 as the minimums, with Go, Ruby and Java versions too.8
Try a question in the Decisions playground before writing code.
Send images as base64 data URLs. Hosted image URLs and file IDs aren't supported in the beta.
Label 100 to 200 of your own cases and set thresholds from them. The guide says the same: pick thresholds from the cost of false positives and false negatives.
If you already call Jev, FOMA's Jev how-to shows the kind of checks worth moving, and the Vercel gateway endpoint serves both models with the same request shape.
Who is the Decisions API for?
Teams already on OpenAI who need a fast yes, no or pick-one inside an app: support routing, content moderation, agent guardrails. Teams whose inputs are images. And teams whose compliance list includes zero retention or HIPAA, where a new vendor contract is the slow part.
It's not the cheap option for text. Jev is cheaper per token and, in the one test we have, steadier at the tail. TypeSafe's story is in FOMA's Jev issue.
So, Decisions API or Jev?
You want to know which decision model to call, and for plain text the answer is Jev: same accuracy in the only independent test, about half the cost per call, fewer slow calls. Pick the Decisions API when your input includes images, when your compliance team needs OpenAI's data controls, or when adding a vendor costs more than the token bill. It's a beta, so re-run your own cases when it reaches general availability.
Notes
The guide's score example: probabilities of 0.1, 0.7 and 0.2 across levels 0, 1 and 2 give a score of 1.1 (OpenAI's guide).
The 10x figure is from the changelog and OpenAI's public beta post. Reports of the DevDay slide put it at about 150 ms against 1.6 seconds for a standard Luna call; that is a vendor claim (agent.nexus).
On GPT-6 Luna, input over 272K tokens bills at 2x, and regional processing adds 10% (model page). The guide says these multipliers apply to /v1/decisions but doesn't restate the figures.
Jev's limits, per TypeSafe's docs: 32K tokens of usable input per call, counting the state plus the longest question, within a 64K ceiling for the whole request (the state plus every question); rate limits of 100K tokens and 80 requests per second; and up to 255 options per choice question (API reference).
Per million calls, $224 against $105 at the testers' measured token counts. Jev counted a mean of 2,504 input tokens per call and Decisions 2,237 on the same calls (agent.nexus).
Billed tokens for one 40-word text, Jev then Decisions: 324 vs 204 with 1 question, 343 vs 360 with 2, 381 vs 672 with 4, and 457 vs 1,296 with 8 (agent.nexus).
Across 6,624 timed calls. At the 95th percentile, 584 ms for Decisions against 388 ms for Jev. Error rates were 10.8% and 10.3% (agent.nexus).