OpenAI Decisions API Guide: GPT-6 Luna Pricing, Answer Types and Python Example (2026)

Most apps do not need an AI to write an essay. They need a quick yes or no: is this a bug report, which team should get this ticket, how risky is this shell command?

That is what OpenAI’s Decisions API is for. It runs on GPT-6 Luna, returns probabilities instead of text, and charges only for input tokens. It left beta on 22 October 2026, and OpenAI’s October developer roundup this week put it back in the spotlight.

This guide covers how it works, the three answer types, pricing with real cost-per-decision maths, a working Python example, limits, errors, and when to use plain Structured Outputs instead.

What Is the OpenAI Decisions API?

The Decisions API is a separate endpoint built for judgments, not text. You give it some evidence (a support ticket, a transcript, a product photo) and a list of questions. It reads the evidence once and answers every question with calibrated probabilities.

Sources: Unite.AI, AIFreeAPI, OpenRouter, DEV Community digest.

The Three Answer Types

Each question has a unique name, which the API echoes back so you can match answers to questions. A refusal on one question does not stop the others.

Tip: add a fallback option such as “other” to choice questions. It stops the model being forced into a wrong bucket.

Pricing and Cost per Decision

Rates from Unite.AI’s GA report and OpenRouter. Regional processing (US/EU) adds a premium.

What that means in practice

• 400-token ticket, one question: about $0.00004, or $40 per million decisions.
• Same input, 20 questions at once: you pay for the input once plus the question text, so asking more questions per request is much cheaper than separate calls.
• Long fixed instructions: keep shared context at the start (1,024+ tokens) so prompt caching applies; question text is not part of the cached prefix.

For the full OpenAI price list, see my OpenAI API pricing guide, and for caching tricks, the prompt caching guide.

How to Use It: Python Step by Step

1. Update the SDK. Run pip install -U openai so client.decisions exists.
2. Set your key. Export OPENAI_API_KEY as usual.
3. Write shared input. A string, or user messages with text, JSON (input_json) and images.
4. Write named questions. One per decision you need, each with a type and clear instructions.
5. Check for refusals before reading type-specific fields.
6. Pick thresholds. Decide what probability triggers an action (for example route if above 0.8, ask a human between 0.5 and 0.8).

A minimal example based on OpenAI’s guide:

from openai import OpenAI

client = OpenAI()

decision = client.decisions.create(
    model="gpt-6-luna",
    input="The app crashes every time I open settings. I'm on the Pro plan.",
    questions=[
        {
            "type": "predicate",
            "name": "is_bug_report",
            "instructions": "Does the message describe a software defect?",
        },
        {
            "type": "choice",
            "name": "team",
            "instructions": "Which team should handle this?",
            "choices": ["mobile", "billing", "web", "other"],
        },
        {
            "type": "score",
            "name": "urgency",
            "instructions": "How urgent is this for the customer?",
            "levels": ["low", "medium", "high"],
        },
    ],
)

for answer in decision.answers:
    if answer.type == "refusal":
        print(answer.name, "refused")
    elif answer.type == "predicate":
        print(answer.name, answer.probability)
    elif answer.type == "choice":
        print(answer.name, answer.choice, answer.confidence)
    elif answer.type == "score":
        print(answer.name, answer.score)

Note: the choice and score field names (choices, levels) follow AIFreeAPI’s and CCLeaks’ descriptions of the schema. Check OpenAI’s Decisions guide if your SDK version differs.

Admins can track spend with GET /v1/organization/usage/decisions, using an admin key with the api.usage.read permission.

Limits and Supported Inputs

• Questions per request: 1 to 400 (was 200 in beta).
• Score levels: 2 to 10, lowest to highest.
• Choice options: 2 to 255 reported in beta.
• Images: base64 data URLs or public HTTP/HTTPS URLs; up to 128 per request reported in beta.
• Not supported: files, audio, file_id, tools and function calls as output.
• Dependent questions: if one answer changes the next question, send separate requests.
• Context: OpenRouter lists 1.1M tokens.
• Rate limits: not published separately; GPT-6 Luna on the Build tier starts at 5,000 requests per minute.
• Compliance: Zero Data Retention and HIPAA for eligible customers; US and EU (EEA + Switzerland) processing.

Real Use Cases and Reported Results

These are customer and vendor claims reported by Unite.AI, not independent tests:

Other good fits: moderation, spam filtering, lead scoring, deciding when a voice agent should escalate, and grading AI outputs against a rubric.

Decisions API vs Responses API vs Structured Outputs

Other labs do not have a direct equivalent endpoint. On Claude or Gemini you would use structured output with a small model such as Claude Haiku 5.5 or Gemini Flash. See my AI API pricing comparison for their rates.

Also New: GPT-6.1 Sol Ultrafast

The same OpenAI developer update highlighted Ultrafast mode for GPT-6.1 Sol:

• Speed: up to 8x faster than Sol Standard, with “near-Astra intelligence” (OpenAI).
• Where: the API, Codex and ChatGPT Work.
• API price: $12 per 1M input tokens and $60 per 1M output tokens (OpenAI Developers on X).
• Codex extras: a Windows sandbox and next-instruction prediction.

For Codex setup and plans, see my OpenAI Codex guide.

Troubleshooting

• AttributeError: 'OpenAI' object has no attribute 'decisions': your SDK is too old. Upgrade with pip install -U openai.
• 403 “Decision API is not enabled for this user”: seen during the preview. Check project restrictions and that your country is supported; it has not been reported since the beta opened.
• Model not found: only gpt-6-luna works on this endpoint.
• Image rejected: use a base64 data URL or a public HTTP/HTTPS URL; file_id is not accepted.
• Too many questions: the cap is 400 per request; split larger batches.
• Answers ignore an earlier answer: questions in one request are independent. Chain dependent decisions across requests.
• Costs higher than expected: make sure your shared context comes first and is 1,024+ tokens so caching applies.

My Take

This is one of the most practical things OpenAI has shipped this year. Classification is the boring backbone of most AI products, and paying only for input while getting probabilities you can threshold is a real upgrade over parsing “yes” from a chat reply.

The trade-off is lock-in: there is one model, no tools and no text output, so you will still need the Responses API next to it.

If you route tickets, moderate content or score risk at volume, test it on a few thousand real examples and compare against your current prompt. I will update this page when OpenAI adds models or publishes rate limits.

FAQ

What is the OpenAI Decisions API?

It is an endpoint, POST /v1/decisions, that answers named questions about your input with probabilities instead of text. It is built for classification, routing and scoring.

How much does the Decisions API cost?

$0.10 per million input tokens, $0.01 for cached input, and nothing for output. A short decision costs a fraction of a cent.

Which model does it use?

Only gpt-6-luna for now.

Is the Decisions API generally available?

Yes. It moved from public beta to general availability on 22 October 2026.

How many questions can I ask in one request?

Up to 400 since GA, double the beta limit of 200.

Can it read images or PDFs?

It reads images (base64 or public URLs) and JSON, but not files, PDFs or audio.

Can I use it from other platforms?

OpenRouter lists it as GPT-6 Luna Decisions, and Vercel AI Gateway supports it as openai/gpt-6-luna-decisions.

Sources

• OpenAI Decisions guide (developers.openai.com, answer types, limits, refusal handling)
• Unite.AI: OpenAI makes Decisions API generally available with GPT-6 Luna (22 Oct 2026)
• AIFreeAPI: Decisions API pricing, request shape and beta limits
• CCLeaks: How to use the OpenAI Decisions API (Oct 2026)
• OpenRouter: GPT-6 Luna Decisions model page
• OpenAI Developers on X: GPT-6.1 Sol Ultrafast launch and pricing
• DEV Community: AI Daily Digest, 6 Nov 2026 (OpenAI October developer update)