Yes, you can call it now. OpenAI released the Decisions API in public beta on October 6, 2026, according to its API changelog. It runs only on gpt-6-luna, through a dedicated endpoint, POST /v1/decisions. OpenAI says it expects general availability "in the coming weeks" but has not given a date.
The price is input-only: $0.10 per 1M input tokens, with no output, cache-read, or cache-write charges, as stated in the Decisions guide. A decision with 400 input tokens costs $0.00004. That is $0.04 per 1,000 decisions and $40 per million, about 16% less than the same label from GPT-6 Luna through the Responses API.
The catch is caching. The endpoint gives no discount for instructions you repeat on every call, while Luna's Responses API bills a cached prefix at a tenth of the input rate. A classifier with a long fixed prompt can therefore cost about a fifth as much on the Responses API when the cache is warm. The cost sections below show the arithmetic and a simple rule for which route is cheaper.
As of October 10, 2026, OpenAI has not published Decisions-specific rate limits or a GA price. Because it is still a beta, keep the call behind one function in your code so a change in the request shape or price touches one place.
What the Decisions API does: bounded questions with predefined answers
You send one input and a list of questions whose answers you define, and you get typed answers back instead of generated text. OpenAI previewed the endpoint at DevDay on September 29, 2026 and positions it for classifying content, routing requests, and prioritizing work.
A request has three parts: model (only gpt-6-luna), input (a text string, or user messages with text and images), and questions. Each question has one of three types:
| Question type | Use it for | What comes back |
|---|---|---|
predicate | A condition that is true or false, such as "Is there visible damage?" | probability: an estimate from 0 to 1 that the condition is true |
choice | Picking one option from a list you supply, such as a department | choice (one of your values), probabilities for every option, and confidence |
score | Rating against ordered levels, such as issue severity | score: the probability-weighted average of the 0-based level indices, plus probabilities and confidence |
Independent questions can share one request, and each can use a different type. When one decision depends on another, for example "pick a repair category only if the photo shows damage," OpenAI's guide says to send separate requests.
It does not write text, explain its answer, or call tools. For those, OpenAI points you to Structured Outputs on the Responses API when you need an object in your own JSON schema, such as extracted fields or a written explanation, and to function calling when the model should request a tool call. It is also unrelated to Decisions, the low-code automation platform at decisions.com, and to decisionapi.net.
Decisions API status as of October 10, 2026: public beta, GA date unannounced
| Question | Answer as of October 10, 2026 |
|---|---|
| Can I call it? | Yes. It has been in public beta since October 6, 2026. OpenAI's community announcement presents it as open to all developers, and no tier requirement is published. |
| What was it before October 6? | A limited preview for selected customers, starting at DevDay on September 29. |
| When is general availability? | OpenAI says "in the coming weeks." There is no date and no announced GA price. |
| Which model? | gpt-6-luna only. |
| Endpoint and SDK | POST /v1/decisions, called with client.decisions.create(...) (client.Decisions.New in Go). The guide's examples need Python SDK 3.26.0, JavaScript 7.30.0, Go 3.73.0, Ruby 0.101.0, or Java 4.78.0 or later. |
| Can I try it without code? | Yes, in the Decisions Playground. |
| Input | Text, images, or both. Up to 128 images per request. |
| Price | $0.10 per 1M input tokens. No output, cache-read, or cache-write charges. The rate sits in the Decisions guide; the main pricing page has no Decisions row. |
| Speed | OpenAI says "about 10x faster than the Responses API" and publishes no benchmark. Classmethod's test measured medians of 255–273 ms on short text requests; one community user reported about 0.8 s with image input. |
| Does it return probabilities? | Yes: probability for predicates, and probabilities plus confidence for choice and score questions. |
| Rate limits | Not published for /v1/decisions. |
| Data controls | Zero Data Retention and HIPAA use for eligible customers; data residency and regional processing in the United States and Europe (EEA plus Switzerland). |
| Free tier access | Not stated. |
One documentation gap to ignore: as of October 10, 2026, the endpoint table on the GPT-6 Luna model page still doesn't list v1/decisions. The Decisions guide and the changelog are the documents that cover the endpoint.
How much does the OpenAI Decisions API cost? $0.10 per 1M input tokens
Cost per decision = input tokens × $0.10 / 1,000,000
Output is free on this endpoint, and in practice it is zero: the API reference example reports "output_tokens": 0, and Classmethod saw output_tokens at 0 in every run. Your bill depends only on how many input tokens each request carries.
| Input tokens per decision (example) | Per decision | Per 1,000 | Per 1,000,000 |
|---|---|---|---|
| 145 (OpenAI's choice sample, as counted by Classmethod) | $0.0000145 | $0.0145 | $14.50 |
| 400 (short instructions plus one support ticket) | $0.00004 | $0.04 | $40 |
| 1,600 (1,500 tokens of fixed instructions plus 100 of ticket text) | $0.00016 | $0.16 | $160 |
The 400- and 1,600-token rows are assumptions. To get your own number, log usage.input_tokens from a sample of real requests and multiply the average by $0.10 per million. These are the things that move it:
- Everything in the request is input. Your instructions, every choice and its description, and every score level count at the full rate on every call. There is no cached-input discount.
- Images add input tokens, and the count depends on the image and its
detailsetting. - Several questions in one request share the input. Because billing is per input token, three independent questions about the same ticket in one request bill the ticket once. Three separate requests bill it three times.
- Regional processing and long context cost more. The guide says regional processing premiums and long-context input multipliers apply. On Luna's model page, regional processing adds 10%, and prompts over 272K input tokens bill input at 2x.
Third-party listings match the official rate. Vercel AI Gateway lists openai/gpt-6-luna-decisions at $0.10 input, and OpenRouter lists "GPT-6 Luna Decisions" at $0.10 per 1M input and $0.00 output. OpenAI hasn't said whether the price will change at general availability.
What a GPT-6 Luna decision costs: $47.50 per million, or $30 with caching
The alternative is the one many teams already run: GPT-6 Luna on the Responses API with a strict enum schema. Its Standard rates per 1M tokens are $0.10 input, $0.01 cached input, $0.125 cache writes, and $0.50 output, with Batch and Flex at half price (GPT-6 Luna model page).
Responses cost per decision = uncached input × $0.10 + cached input × $0.01 + output × $0.50, all per 1,000,000 tokens
| Example workload | GPT-6 Luna, Responses API | Decisions API | Cheaper route |
|---|---|---|---|
| 400 input + 15 output tokens, prompt too short to cache | $47.50 per million | $40 per million | Decisions, by $7.50 per million (about 16%) |
| 1,500 fixed (cached) + 100 variable input + 10 output tokens, cache warm | $30 per million | $160 per million | Responses, about 5.3x cheaper |
| 400 input + 15 output tokens through the Batch API | $23.75 per million | No batch option documented | Responses, if you can wait for results |
Check the middle row yourself: (1,500 × $0.01 + 100 × $0.10 + 10 × $0.50) / 1,000,000 = $0.00003 per decision, or $30 per million. The Decisions API bills all 1,600 tokens at $0.10: $160 per million. The token counts are examples; replace them with your own logged averages.
The break-even follows from the two formulas. Call the cached prefix P, the uncached input V, and the output O, all in tokens. Decisions costs 0.10 × (P + V). Responses with a cache hit costs 0.01 × P + 0.10 × V + 0.50 × O. Decisions is cheaper only while 0.09 × P is less than 0.50 × O, that is, while P is smaller than 5.6 × O.
Prompt caching only starts at a 1,024-token prefix on GPT-5.6 and later models. At that minimum prefix, the Responses call would have to produce about 184 output tokens before Decisions became cheaper, far more than a one-word label needs. In practice:
- Your whole prompt is under 1,024 tokens: nothing can be cached, so Decisions is cheaper by the cost of the output tokens you no longer pay for.
- Your instructions and labels form a fixed prefix of 1,024 tokens or more, and traffic reuses it within 30 minutes: Responses is cheaper on every cache hit. A cached prefix stays reusable for at least 30 minutes after its last write or reuse.
- Your traffic is bursty with long gaps: misses write the cache at $0.125 per 1M, which narrows the gap. Compare your logged
cached_tokensbefore deciding.

Price per token isn't the whole decision. The Decisions API returns probabilities, which an enum label doesn't, and OpenAI says it is about 10x faster. In eesel AI's test, Luna with a strict schema and reasoning set to none had a median of 1.46 s per decision, measured end to end from a laptop. If you stay on Luna, keep reasoning.effort at none: reasoning tokens bill at the output rate, and eesel measured the same routing job at $0.047 per 1,000 tickets with none and $0.089 with medium.
To compare Luna with the larger Sol model for the same workload, see GPT-6 Luna vs. Sol pricing: calculate the cost of your workload.
How to call POST /v1/decisions: predicate, choice, and score
You need an OpenAI API key with credits in OPENAI_API_KEY (see OpenAI API Key: How to Get One, Use It, and What It Costs) and, for Python, pip install --upgrade "openai>=3.26.0". The requests below follow the shapes in OpenAI's guide and API reference; send one test request with your own key before building on them.

The shortest request is a single choice question with plain text input, taken from OpenAI's guide:
curl https://api.openai.com/v1/decisions \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-6-luna",
"input": "I was charged twice for my order.",
"questions": [{
"type": "choice",
"name": "department",
"instructions": "Which department should handle this complaint?",
"choices": [
{"value": "billing", "description": "Payments, invoices, and refunds."},
{"value": "technical", "description": "Problems using the product."},
{"value": "shipping", "description": "Delivery and tracking."},
{"value": "other", "description": "Requests outside these categories."}
]
}]
}'In Python, one request can ask all three question types about the same ticket, because none depends on another's answer:
from openai import OpenAI
client = OpenAI() # reads OPENAI_API_KEY
decision = client.decisions.create(
model="gpt-6-luna",
input="I was charged twice for order #4471 and need the refund before Friday.",
questions=[
{
"type": "choice",
"name": "department",
"instructions": "Which department should handle this request?",
"choices": [
{"value": "billing", "description": "Payments, invoices, and refunds."},
{"value": "technical", "description": "Problems using the product."},
{"value": "shipping", "description": "Delivery and tracking."},
{"value": "other", "description": "Requests outside these categories."},
],
},
{
"type": "predicate",
"name": "asks_for_refund",
"instructions": "Does the customer explicitly ask for a refund?",
},
{
"type": "score",
"name": "urgency",
"instructions": "How urgent is this request?",
"levels": [
{"label": "Routine", "description": "No deadline or impact mentioned."},
{"label": "Soon", "description": "The customer wants action within days."},
{"label": "Urgent", "description": "Money already lost or a same-day deadline."},
],
},
],
)
for answer in decision.answers: # same order as the questions
if answer.type == "refusal":
print(f"{answer.name}: refused")
elif answer.type == "choice":
print(answer.name, answer.choice, answer.confidence, answer.probabilities)
elif answer.type == "predicate":
print(answer.name, answer.probability)
elif answer.type == "score":
print(answer.name, answer.score, answer.confidence, answer.probabilities)
print("billed input tokens:", decision.usage.input_tokens)OpenAI's guide shows this illustrative response for the curl request above:
{
"answers": [
{
"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
}
]
}| Field | Appears on | What it means |
|---|---|---|
name | Every answer | The name you gave the question, echoed back (null if you gave none) |
probability | Predicate | Estimated probability, from 0 to 1, that the condition is true |
choice | Choice | One of your supplied values. Values are typed, so "true" and true are different choices |
probabilities | Choice, score | A probability for every option. Score entries also carry the level's index (value) and label |
confidence | Choice, score | A separate confidence number. OpenAI doesn't document how it is computed |
score | Score | The probability-weighted average of level indices. Probabilities of 0.1, 0.7, and 0.2 on levels 0, 1, and 2 give 1.1 |
type: "refusal" | Any answer | The model declined that question. Other questions in the request can still be answered |
usage.input_tokens | Response | The number you pay for |
For images, put input_text and input_image parts in a user message and send each image as a base64 data URL (data:image/png;base64,...). The guide says hosted HTTP(S) URLs aren't supported, while the API reference says publicly accessible URLs work. Base64 is valid under both documents, so use it until they agree.
Decisions API limits: 2–255 choices, 128 images, no published rate limits
| Limit | Value as of October 10, 2026 |
|---|---|
| Model | gpt-6-luna only |
Options per choice question | Between 2 and 255, each unique; values are strings or booleans |
| Images | Up to 128 per request across all messages; detail can be low, high, auto, or original |
| Image source | Base64 data URLs (hosted URLs disputed between guide and reference); file IDs aren't accepted |
| Message roles | user only |
| Not supported | Files, audio, tools and function calls, item references |
| Questions per request | Not published |
Levels per score question | Not published |
safety_identifier | Optional, up to 128 characters |
| Rate limits | Not published for /v1/decisions |
| Cache discount | None |
One older figure no longer applies. On October 6, 2026, OpenAI replaced its five usage tiers with three, Build, Launch, and Grow, so the old "Tier 1: 500 RPM" limit for Luna is obsolete. Luna's Responses limits now start at 5,000 RPM and 2,000,000 TPM on Build, rising to 10,000 RPM on Launch and 30,000 RPM on Grow (rate limits guide). OpenAI doesn't say whether those limits also cover /v1/decisions, so check Settings > Organization > Limits in your dashboard and the rate-limit headers on real responses before you size a backlog job.
Can your key use it? What "Decision API is not enabled for this user" means
With a standard API key, it should work now. That error was the gate for the preview, before the public beta. eesel AI's author called POST https://api.openai.com/v1/decisions on October 1 and again on October 2, 2026, and both times got HTTP 403:
{
"error": {
"message": "Decision API is not enabled for this user.",
"type": "invalid_request_error",
"param": null,
"code": null
}
}No public reports of that 403 have appeared since October 6. Classmethod's tests, published October 7, reported no access errors, and neither did the testers in OpenAI's community thread.
To check your own account, send the minimal request from the API reference:
curl https://api.openai.com/v1/decisions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-6-luna",
"input": "The package arrived with a broken screen.",
"questions": [
{
"type": "predicate",
"name": "damaged",
"instructions": "Does the customer report a damaged item?"
}
]
}'A working account gets an answers array with a probability and a usage block. If you get an error instead, OpenAI hasn't documented the causes, but these are the things to rule out:
- An old SDK. If your client has no
decisionsattribute, upgrade to at least Python 3.26.0 or JavaScript 7.30.0. - A wrong path or model. The path is
/v1/decisionsand the model must begpt-6-luna. - A project or organization restriction. If an admin limits which models a project can use, try a key from another project or ask the admin.
- An unsupported country. Direct OpenAI API accounts need an allowed country.
Decisions API or GPT-6 Luna with a strict enum: which to run
| Your situation | Use | Why |
|---|---|---|
| Short prompts (under 1,024 tokens) and you want the answer fast | Decisions API | Cheaper by the output tokens, and OpenAI says about 10x faster |
| You need a probability to set an "act" or "review" threshold | Decisions API | It returns probability or probabilities; an enum label doesn't |
| Image inputs such as product photos or screenshots | Decisions API | Takes up to 128 images per request |
| A long fixed instruction block or a big label list, with steady traffic | GPT-6 Luna on Responses with prompt caching | $30 vs $160 per million in the example above |
| Relabeling a backlog with no latency requirement | GPT-6 Luna through the Batch API | $23.75 per million at 400 input and 15 output tokens |
| You need your own JSON object, extracted fields, a reason, or a tool call | Responses with Structured Outputs or function calling | OpenAI's own guidance for those outputs |
| More than 255 options for one question | GPT-6 Luna strict enum | A schema can hold up to 1,000 enum values in total |
| You reach OpenAI models only through a gateway | Check whether it lists Decisions | See the gateway notes below |
Move a Luna enum classifier to /v1/decisions with one decide() swap
If you already route tickets with GPT-6 Luna and a strict enum schema, you don't have to rewrite your app. Keep the labels and instructions in one place, add a second backend, and switch with one line once your own data shows the new one is at least as accurate.
The Luna side relies on Structured Outputs in strict mode: the model's output must match your JSON Schema, so a schema whose only property is an enum limits the answer to your list, and the output is an object such as {"queue":"billing"}. Three schema rules trip people up: the root must be an object, every property must be listed in required, and every object needs "additionalProperties": false.
Python: one decide() interface with a Luna backend and a Decisions backend
Both classes return the same Decision, so the rest of your app never sees which endpoint answered. The Decisions version reuses the same queue names, turns the enum into choice options with descriptions, and sends low-confidence answers to review.
import base64
import json
import mimetypes
from dataclasses import dataclass
from typing import Optional, Protocol
from openai import OpenAI # openai>=3.26.0 for client.decisions
QUEUES = {
"billing": "Payments, invoices, and refunds.",
"shipping": "Delivery and tracking.",
"technical": "Problems using the product.",
"needs_review": "Fits none of the queues, mixes several, or is unclear.",
}
FALLBACK = "needs_review"
INSTRUCTIONS = (
"Route the support request to exactly one queue. If it fits none of them, "
"mixes several, or you cannot tell, answer needs_review."
)
SCHEMA = {
"type": "object",
"properties": {"queue": {"type": "string", "enum": list(QUEUES)}},
"required": ["queue"],
"additionalProperties": False,
}
@dataclass
class Decision:
answer: str
backend: str
confidence: Optional[float] = None
class Decider(Protocol):
def decide(self, text: str, image_path: Optional[str] = None) -> Decision: ...
def user_content(text: str, image_path: Optional[str]) -> list:
"""Text plus an optional image as a base64 data URL (valid on both endpoints)."""
content = [{"type": "input_text", "text": text}]
if image_path:
mime = mimetypes.guess_type(image_path)[0] or "image/png"
with open(image_path, "rb") as f:
b64 = base64.b64encode(f.read()).decode("ascii")
content.append({"type": "input_image", "image_url": f"data:{mime};base64,{b64}"})
return content
class LunaDecider:
"""GPT-6 Luna on the Responses API with a strict enum schema."""
def __init__(self, client: Optional[OpenAI] = None):
self.client = client or OpenAI() # reads OPENAI_API_KEY
def decide(self, text: str, image_path: Optional[str] = None) -> Decision:
response = self.client.responses.create(
model="gpt-6-luna",
reasoning={"effort": "none"},
max_output_tokens=50,
input=[
{"role": "developer", "content": INSTRUCTIONS},
{"role": "user", "content": user_content(text, image_path)},
],
text={"format": {"type": "json_schema", "name": "ticket_route",
"strict": True, "schema": SCHEMA}},
)
# Incomplete output (for example, max_output_tokens reached) goes to review.
if response.status != "completed":
return Decision(FALLBACK, "luna:incomplete")
message = next((item for item in response.output if item.type == "message"), None)
part = message.content[0] if message and message.content else None
# A safety refusal does not follow your schema, so it goes to review too.
if part is None or part.type != "output_text":
return Decision(FALLBACK, "luna:refusal")
return Decision(json.loads(part.text)["queue"], "luna")
class DecisionsApiDecider:
"""The same decision through POST /v1/decisions."""
def __init__(self, client: Optional[OpenAI] = None, min_confidence: float = 0.8):
self.client = client or OpenAI()
self.min_confidence = min_confidence # placeholder: set it from labeled data
def decide(self, text: str, image_path: Optional[str] = None) -> Decision:
decision = self.client.decisions.create(
model="gpt-6-luna",
input=[{"role": "user", "content": user_content(text, image_path)}],
questions=[{
"type": "choice",
"name": "queue",
"instructions": INSTRUCTIONS,
"choices": [{"value": v, "description": d} for v, d in QUEUES.items()],
}],
)
answer = decision.answers[0]
if answer.type == "refusal":
return Decision(FALLBACK, "decisions:refusal")
if answer.confidence < self.min_confidence:
return Decision(FALLBACK, "decisions:low_confidence", answer.confidence)
return Decision(answer.choice, "decisions", answer.confidence)
if __name__ == "__main__":
decider: Decider = DecisionsApiDecider() # or LunaDecider()
print(decider.decide("I was charged twice for order #4471."))
# With a screenshot:
# print(decider.decide("Customer says the app crashes here.", "crash.png"))The 0.8 cutoff is only a placeholder. Early tests (see the calibration section below) saw choice confidence sit at 1.0 run after run, so a cut on it may filter little until you have checked it against labeled examples.
To switch safely:
- Run both deciders on the same live traffic for a while, acting only on the Luna answer (shadow mode).
- Compare agreement, error rate per label against human decisions, latency, and cost per 1,000 from each response's
usage. - Change the one line that picks the decider once the Decisions backend is at least as accurate on your labels.
If you evaluated Luna on images before September 25, 2026, rerun that evaluation first. OpenAI's changelog says it fixed an image-encoding bug that day that had degraded image understanding in GPT-6 Sol and Luna.
Through Chat Completions or a third-party gateway
Chat Completions takes the same Luna schema under response_format, which helps if your stack is built on it or you call Luna through an OpenAI-compatible provider:
response = client.chat.completions.create(
model="gpt-6-luna",
reasoning_effort="none",
messages=[
{"role": "system", "content": INSTRUCTIONS},
{"role": "user", "content": "I was charged twice for order #4471."},
],
response_format={
"type": "json_schema",
"json_schema": {"name": "ticket_route", "strict": True, "schema": SCHEMA},
},
)
queue = json.loads(response.choices[0].message.content)["queue"]Gateways now carry the Decisions API itself. Vercel AI Gateway lists it as openai/gpt-6-luna-decisions, and OpenRouter lists "GPT-6 Luna Decisions." Their request formats can differ from OpenAI's /v1/decisions (Vercel's goes through its AI SDK), so check each gateway's docs rather than pointing the code above at them.
If you can't pay OpenAI directly and only need the Luna route, laozhang.ai lists gpt-6-luna on its OpenAI-compatible endpoint at $0.10 input and $0.50 output per 1M tokens. It doesn't list the Decisions API. Point OpenAI(base_url="https://api.laozhang.ai/v1", api_key=...) at it and send one test call to confirm the strict schema is enforced before relying on it.
Can you trust probability and confidence? Early tests say calibrate first
Not blindly. A probability is not automatically a calibrated one. OpenAI's own advice is to set thresholds from labeled examples, based on what a false positive and a false negative cost you. Early third-party tests show why:
- Choice probabilities ran high. In Classmethod's five runs of OpenAI's own choice sample, the answer came back with probability 1.0 and confidence 1.0 every time, where the guide's illustrative response shows 0.95 and 0.93. The score sample returned 0.97 with confidence 0.96 rather than the illustrative 1.1 and 0.55. Values were identical across runs and had two decimal places.
- Predicates tracked reality better than choices in one community test. On a coin biased 70% toward one side, a predicate returned about 70%, while a choice question returned about 98%. The same tester saw choice probabilities shift when the options were reordered.
- Routing is the easy call. In eesel AI's test of 20 support tickets run twice, Luna picked the right queue 40 of 40 times, but answered "is this safe to auto-reply?" correctly 33 of 40 times at reasoning
none. It is a small test by a vendor that sells helpdesk automation, yet it matches a useful rule: deciding whether to act is harder than deciding where something goes.
These are small tests, not OpenAI statements. They suggest using a predicate when the probability itself drives an action, and not trusting a choice's probability until you have measured it.
Before a label sends, spends, or changes anything: add a review path
A valid label is not a correct label. For any decision that sends a message, spends money, or changes data:
- Give every question an escape answer. OpenAI's guide recommends a fallback option such as
other; the code above usesneeds_reviewand sends it to a person. - Treat refusals, incomplete responses, and low confidence the same way. Both deciders above already do.
- Run in shadow mode first. Log the model's answer next to the human decision on real traffic and measure error rates per label.
- Set thresholds from that log, separately for each label and action, then let only low-risk labels act automatically.
- Log enough to recheck later: input, answer, probabilities, model, instructions version, and the final outcome.
OpenAI Decisions API FAQ
When will the OpenAI Decisions API be released?
It already is, as a public beta. OpenAI released it on October 6, 2026, after a limited preview that began at DevDay on September 29. OpenAI expects general availability "in the coming weeks" but hasn't named a date or said whether the price or request shape will change.
How much does the Decisions API cost?
$0.10 per 1M input tokens, with no charge for output, cache reads, or cache writes. A 400-token decision costs $0.00004, which is $40 per million decisions. There is no cache discount, so a long fixed prompt that GPT-6 Luna can cache on the Responses API may be cheaper there: $30 per million versus $160 in the 1,600-token example above.
Is the Decisions API available in ChatGPT?
No. It is an API endpoint for developers, POST /v1/decisions, with a Playground in the OpenAI API platform at platform.openai.com/decisions. Nothing in OpenAI's documentation describes it as a ChatGPT feature.
How does the Decisions API compare with TypeSafe's Jev?
Third-party results are mixed and name no clear winner. In Classmethod's combined test, Decisions had a median of 255 ms against Jev's 238 ms and cost $0.0000406 per request against Jev's $0.0000169. One community tester found Jev more accurate on judgment calls and faster, with Luna about equal on simple checks. Another tester on X saw nearly identical scores on document checks and rule-based routing. The clear differences are that the Decisions API accepts images, which Jev doesn't, and runs inside OpenAI's platform with its data controls.
Does the Decisions API return a confidence score?
Yes. choice and score answers include a confidence field and a probabilities array, and predicate answers return a probability from 0 to 1. OpenAI doesn't document how confidence is computed, and in one community test a choice question returned about 98% on a coin that lands one way 70% of the time. Set thresholds from your own labeled examples.
Can I get the Decisions API through a third-party gateway?
Yes, some gateways now list it. Vercel AI Gateway offers openai/gpt-6-luna-decisions at $0.10 per 1M input tokens, and OpenRouter lists "GPT-6 Luna Decisions" at $0.10 input and $0.00 output. Their request formats can differ from OpenAI's endpoint, so follow each gateway's docs. OpenAI-compatible providers that list only gpt-6-luna, such as laozhang.ai, give you the strict-enum route, not the Decisions API.
Does the Decisions API support prompt caching discounts?
No. Every input token is billed at $0.10 per 1M, including instructions and options you repeat on every call. The Responses API bills a cached prefix of 1,024 tokens or more at $0.01 per 1M, which is why long, fixed prompts can be cheaper there.






