What Is the OpenAI Decisions API?

OpenAI's Decisions API (POST /v1/decisions, GPT-6 Luna, GA since Oct 22, 2026) turns text, images and JSON into predicate, choice and score answers with probabilities, at $0.10 per 1M input tokens ($0.01 cached) and no output charge. What it returns, costs, and when to pick it.

INEZA Felin-Michel

INEZA Felin-Michel

26 October 2026

What Is the OpenAI Decisions API?

Apidog for Enterprise

On-Premises Deploy

SSO & RBAC

SOC 2 Compliant

Explore Apidog Enterprise

The OpenAI Decisions API is a POST /v1/decisions endpoint, running on GPT-6 Luna, that takes text or images plus a list of questions and returns typed answers instead of prose: a predicate probability, a choice with per-option probabilities, or a score over ordered levels. Input costs $0.10 per 1M tokens (cached input $0.01) with no output-token charge, and the endpoint has been generally available since 2026-10-22, after a public beta that opened on 2026-10-06.

Below: what it returns, what it costs, where it fits next to Structured Outputs, and how to test it. For the walkthrough with curl, Python and JavaScript, read how to use the OpenAI Decisions API next; if you’re already on the Responses API, the Decisions vs Responses comparison shows the same job done both ways. We’ll use Apidog to save requests and assert on the answers array so a model change fails a test instead of misrouting a ticket.

Anatomy of a Decisions request and response

No id, no generated text, nothing to parse.

Part Field What it holds
Request model gpt-6-luna, the only model available today
Request input A string, or an array of messages: user content mixing input_text, input_image and input_json parts, plus developer/system text, assistant messages, and function or custom tool calls with their outputs
Request questions 1 to 400 questions, each with a type, required instructions, and an optional name
Request safety_identifier Optional end-user id, up to 128 characters
Response model Echoes gpt-6-luna
Response answers One entry per question, in the order you asked, with type and name
Response usage input_tokens, input_tokens_details, output_tokens, output_tokens_details, total_tokens

There’s no temperature, reasoning, stream, store, tools or text.format; for those you want the Responses API. output_tokens is 0 in OpenAI’s reference example, which is why pricing has no output line.

The three question types

Each question carries its own type, and you can mix types on one input, up to 400 questions per request at GA (the beta capped it at 200). Put independent questions in the same request; for decisions that depend on an earlier answer, OpenAI’s guide says to send separate requests.

predicate: a yes/no probability

A predicate asks whether a condition holds and returns a probability from 0 to 1 that it’s true.

curl https://api.openai.com/v1/decisions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna",
    "input": "The box arrived crushed and the screen is cracked.",
    "questions": [
      {"type": "predicate", "name": "damaged",
       "instructions": "Is the product described as damaged?"}
    ]
  }'

OpenAI’s reference example for this shape returns:

{
  "model": "gpt-6-luna",
  "answers": [
    {"type": "predicate", "name": "damaged", "probability": 0.95}
  ],
  "usage": {
    "input_tokens": 42,
    "input_tokens_details": {"cached_tokens":0,"cache_write_tokens":0},
    "output_tokens": 0,
    "output_tokens_details": {"reasoning_tokens":0},
    "total_tokens": 42
  }
}

choice: one label from an unordered set

A choice adds a choices array of unique {value, description} objects, where value is a string or a boolean (true and "true" are distinct). OpenAI recommends a fallback such as other when your categories don’t cover every input.

{
  "model": "gpt-6-luna",
  "input": "I was charged twice for my order.",
  "questions": [
    {"type": "choice", "name": "department",
     "instructions": "Which team should handle this ticket?",
     "choices": [
       {"value":"billing"}, {"value":"technical"},
       {"value":"shipping"}, {"value":"other"}
     ]}
  ]
}

The guide’s illustrative answer for this input:

{"type": "choice", "name": "department", "choice": "billing",
 "probabilities": [
   {"value":"billing","probability":0.95},
   {"value":"technical","probability":0.02},
   {"value":"shipping","probability":0.01},
   {"value":"other","probability":0.02}
 ],
 "confidence": 0.93}

score: a position on an ordered scale

A score adds levels, an array of 2 to 10 {label, description} entries ordered lowest to highest. Indices start at 0, and the returned score is the probability-weighted average of those indices, so it can land between levels.

{
  "model": "gpt-6-luna",
  "input": "Export fails in Safari but works in Chrome.",
  "questions": [
    {"type": "score", "name": "severity",
     "instructions": "How badly does this bug block the user?",
     "levels": [
       {"label":"Cosmetic"},
       {"label":"Workaround available"},
       {"label":"Fully blocked"}
     ]}
  ]
}

In the guide’s example the probabilities are 0.1, 0.7 and 0.2 across the three levels, giving a score of 1.1 and a confidence of 0.55. Read 1.1 as “between level 1 and level 2, close to 1”. The guide’s rule: choice for unordered categories such as departments; score for ordered levels such as severity.

A fourth answer type, refusal, can appear for any single question as {"type":"refusal","name":...}. Other questions in the same request can still get answers, so branch on type before reading a field.

Speed, as OpenAI describes it

The launch page says up to 10x faster than GPT-6 Luna through the Responses API. OpenAI publishes no absolute latency number. In its own evaluation, Box reported about 5x faster route selection than Responses at the same accuracy on 30 certificate-of-insurance cases. Measure your own p95 before promising anything. For voice, GPT-Live integrates natively: a session.triggers entry with type: "decisions" emits decision.event during a live session.

Pricing: $0.10 per million input tokens, no output charge

With gpt-6-luna, input costs $0.10 per 1M tokens and there’s no output-token charge. Prompt caching now applies: cached input is $0.01 per 1M, and cache writes cost $0.125 per 1M (30-minute) or $0.25 per 1M (12-hour). A prefix must reach 1,024 tokens to cache (question content doesn’t count), and the default breakpoint sits at the end of the shared input. usage reports cached_tokens and cache_write_tokens.

Input over 272K tokens is $0.20 per 1M ($0.02 cached), and regional processing through the US or EU data-residency endpoints adds 10%. No Batch or Flex tier is documented for /v1/decisions.

Here’s the arithmetic for a support-routing workload. A 500-token uncached ticket with three questions in one request costs 500 / 1,000,000 x $0.10 = $0.00005. One million such tickets cost $50. If every request also repeats a 2,000-token policy prefix, a cache hit bills it at $0.00002 instead of $0.0002, a 90% cut on that prefix. On Responses, a 40-token JSON label adds $0.00002 of output per request, before reasoning tokens; Decisions bills no output tokens at all. For how prompt caching works and the full Luna rate card, see what is GPT-6 Luna.

When to use Decisions, Structured Outputs, or function calling

OpenAI draws the line itself: use Structured Outputs with the Responses API when you need an object that follows your own JSON schema, such as extracted fields or a written explanation, or function calling when you need the model to request a tool call with arguments. Decisions is for classifying content, routing requests, and prioritizing work.

You need Use
A label, a probability, or a severity with confidence Decisions API
An object in your own JSON schema (extracted fields, an explanation) Structured Outputs on Responses
The model to pick a tool and fill its arguments Function calling on Responses
Streaming, stored conversation state, tool execution, or Batch Responses API

A Structured Outputs enum can return a label, but a probability or confidence it writes is generated text, not a measured probability. Decisions gives you numbers you can threshold; OpenAI says to set thresholds from your own labeled examples, weighing false positives against false negatives. Weighing a second typed-decision vendor? The Decisions vs Jev comparison covers price, inputs and output shapes side by side.

Images, JSON and conversation input

User messages mix input_text, input_image and input_json parts. Per the Decisions guide, an image can be a base64 data URL or a public HTTP(S) URL; file_id, files and audio aren’t supported. An input_json part carries a data object or array, so a ticket record goes in as data, not a stringified blob. Question instructions can also be an array of text and image parts, so a question can carry its own reference image.

input also takes developer or system text, assistant messages, and function or custom tool calls with their outputs (matched by call_id), so you can pass a conversation’s history as-is.

Data controls

The Decisions API supports Zero Data Retention and HIPAA use for eligible customers. Data residency and regional processing cover the US and Europe (EEA plus Switzerland) via us.api.openai.com and eu.api.openai.com. GA added Private Link, inference residency in the US and EU, and extra capacity in several Asia regions. Abuse-monitoring logs are kept up to 30 days by default. If you’re routing patient messages, read our HIPAA API compliance guide first.

Availability: generally available since October 22, 2026

The endpoint opened in beta on 2026-10-06, gained GPT-Live integration on 2026-10-15, and went GA on 2026-10-22 with gpt-6-luna only; the changelog lists each step. Launch customers include Box, Datadog, Ramp, Sierra and Speak. To track spend, GET /v1/organization/usage/decisions takes an admin key with api.usage.read; num_model_requests counts requests, not questions. You’ll need an OpenAI API key. SDK examples require Python 3.26.0, JavaScript 7.30.0, Go 3.73.0, Ruby 0.101.0 or Java 4.78.0 or later, and the Playground at platform.openai.com/decisions lets you try questions first. No Decisions-specific rate limits are published; check your organization’s limits page. There’s no free Decisions tier; for no-cost Luna access, see our Luna free routes post.

Testing Decisions calls in Apidog

Typed answers are easy to assert on, which is the point. Three steps cover most teams.

Store the key once. Put OPENAI_API_KEY in an Apidog environment variable and reference {{OPENAI_API_KEY}} in the Authorization: Bearer header, so the literal key never lands in a shared request.

Save one request per question type, with JSONPath assertions: status 200, $.answers[0].type equals choice, $.answers[0].choice equals billing, $.answers[0].confidence greater than 0.8, $.answers[?(@.name=='damaged')].probability greater than 0.9, and $.usage.output_tokens equals 0, which catches a billing surprise before your invoice does.

Pick thresholds from a labeled set. Build an Apidog test scenario that runs the request over a CSV of ticket text and expected department, then set the auto-route threshold where false-positive cost crosses review-queue cost. Run it in CI with the Apidog CLI so a model or alias change fails a test instead of a customer. The how-to guide covers each step, including mocking the answers array so the frontend can be built before the router is final.

FAQ

Is the Decisions API a new model? No. It’s an endpoint, POST /v1/decisions, that runs on GPT-6 Luna. Luna launched 2026-09-22; the endpoint opened in beta on 2026-10-06 and went GA on 2026-10-22.

What does the Decisions API cost? $0.10 per 1M input tokens and no output charge. Cached input is $0.01 per 1M; cache writes are $0.125 (30-minute) or $0.25 (12-hour) per 1M. Input over 272K tokens is $0.20 per 1M, and regional processing adds 10%.

Does it return my own JSON schema? No. It returns answers with probability, choice, or score fields. For your own schema, use Structured Outputs on the Responses API.

How accurate is it? OpenAI publishes no accuracy or calibration figures. Set thresholds from your own labeled data; a data-driven LLM test scenario is the practical way.

Where to start

Pick one routing decision your app makes today with a regex or a prompt-and-parse loop, write it as a single choice question with an other fallback, and run it over 50 labeled examples. If the confidence distribution separates cleanly, you have a threshold and a test. If it doesn’t, the question needs sharper criteria. To run that experiment with saved requests and assertions, download Apidog and import the curl above.

button

Explore more

What Is ERNIE 5.5 Flash?

What Is ERNIE 5.5 Flash?

ERNIE 5.5 Flash is Baidu's 280B-parameter MoE with 14B active and a 1M-token context, released as a Base checkpoint and a post-trained Preview. Here is how the two differ, what the architecture changes, what Baidu's benchmarks show and how to access it.

12 November 2026

What Is MiniMax H3-Image?

What Is MiniMax H3-Image?

MiniMax H3-Image generates and edits 16-megapixel images, and its weights are open under a community license. Here is what MiniMax claims, what the license allows, where to use it and what it costs.

11 November 2026

Qwen4-Max vs Qwen 3.8: What Changed and What You Can't Compare Yet

Qwen4-Max vs Qwen 3.8: What Changed and What You Can't Compare Yet

Qwen4-Max is a preview with no benchmarks, context length or per-token price yet; Qwen3.8-Max is a released model at $2/$6 per 1M tokens. Here's what you can compare today and how to test both yourself.

11 November 2026

Practice API Design-first in Apidog

Discover an easier way to build and use APIs

What Is the OpenAI Decisions API?