OpenAI Decisions API: Price, Endpoint, Outputs and Examples

OpenAI has opened the Decisions API to all developers in public beta, giving applications a dedicated way to classify, route and score text or images without asking a general-purpose model to generate a long response. The API is powered by gpt-6-luna, uses the dedicated POST /v1/decisions endpoint, and supports three typed output modes: predicates, choices and scores.

OpenAI says the endpoint can make decisions up to 10 times faster than running comparable work through GPT-6 Luna in the Responses API. That makes it especially interesting for latency-sensitive moderation, routing, triage and ranking systems.

OpenAI Decisions API at a glance

OpenAI announced the public beta on October 6, 2026 in the OpenAI Developer Community.

What is the Decisions API?

The Decisions API is a constrained inference endpoint. Instead of asking a model to write arbitrary text, you define one or more questions about shared evidence and tell the API what type of answer you need.

That narrower contract is the point. Many production systems do not need prose; they need a machine-readable answer such as:

• “Is this support ticket urgent?”
• “Which department should receive this request?”
• “How severe is this issue on a five-level scale?”

The API evaluates the input and returns typed values your application can act on directly.

The three output types

1. Predicate

A predicate estimates the probability that a statement or condition is true. It is useful when your downstream code needs a confidence value rather than a generated yes/no sentence.

Example: “Does this message contain a refund request?” The result can be used with your own threshold — perhaps route automatically above 0.90, send to review between 0.60 and 0.90, and ignore below 0.60.

2. Choice

A choice selects from a fixed set of options and returns confidence information. This is a natural fit for ticket routing, intent classification, product categorization and selecting which tool or model should handle a request.

Example choices might be billing, technical_support, sales and other.

3. Score

A score evaluates the input against an ordered rubric or numeric range. This is useful for severity, quality, priority or risk levels where the options have a meaningful order.

Unlike an unordered choice, a score can represent progression — for example low, medium, high and critical.

Basic request structure

A Decisions request has three core pieces:

• model — currently gpt-6-luna.
• input — shared text, or a user message containing text and supported image input.
• questions — the conditions, choices or scoring rubrics you want evaluated.

{
  "model": "gpt-6-luna",
  "input": "Customer says the app charged them twice and they need a refund.",
  "questions": [
    {
      "name": "route",
      "type": "choice",
      "choices": ["billing", "technical", "sales"]
    }
  ]
}

The exact schema can evolve during beta, so production integrations should follow the current OpenAI Decisions documentation rather than hard-coding assumptions from launch-day examples.

Decisions API pricing

Launch coverage of the public beta describes the endpoint as input-token-only pricing at $0.10 per 1 million input tokens, with no generated-output token charge because the API returns constrained typed decisions rather than open-ended text.

Pricing is one of the fastest-changing parts of an API product. Before building cost forecasts, confirm the current amount on OpenAI’s official pricing or Decisions documentation, especially once the endpoint moves from beta toward general availability.

Why the endpoint can be faster than Responses API

A normal model response may need to plan and generate multiple output tokens, even if the application only needs one classification. The Decisions API can optimize for a much narrower result shape.

OpenAI’s launch claim is “up to 10x faster” than GPT-6 Luna through the Responses API for comparable decision work. “Up to” is important: actual latency depends on input size, image processing, number of questions, network conditions and the specific classification task.

When should you use Decisions instead of Structured Outputs?

Use the Decisions API when your answer space is bounded and the job is fundamentally a decision. Examples include choosing one route, estimating a predicate, or applying an ordered score.

Use Responses API with Structured Outputs when you need a richer custom JSON object, generated fields, tool calling, multi-step reasoning or a schema that contains more than decision values.

That distinction can prevent overengineering. A support router does not need a full natural-language response; a research assistant that must return citations, summaries and actions probably does.

Practical use case: model routing

One of the most interesting uses is deciding which model should answer a request. A low-cost decision can classify a prompt as simple, coding-heavy, image-dependent or reasoning-intensive, then send it to the right downstream model.

This is particularly relevant now that developers have multiple model tiers. AVARIXO’s guide to the GPT-6 Astra and GPT-6.1 Sol speed update explains another part of that model-selection tradeoff.

Practical use case: support ticket routing

A support system can submit the message once and ask several questions:

• Which team should receive it?
• Is it urgent?
• What severity score should it receive?
• Does it contain a refund or cancellation request?

Because the questions share one input, an application can avoid several separate generative calls for information that is naturally evaluated together.

Practical use case: content moderation triage

The endpoint can be useful as a first-pass classifier when a company has its own policy categories or escalation rubric. The application can ask bounded questions and route uncertain cases to a human reviewer.

For safety-sensitive systems, confidence should not be treated as a guarantee. Teams should test thresholds against real data and preserve human review for consequential decisions.

Image inputs

OpenAI says the Decisions API accepts both text and images. That allows tasks such as checking whether a product photo meets a visual rule, classifying a screenshot into a workflow, or scoring an image against a defined rubric.

During the beta, image-input formats and limits may be narrower than in other OpenAI endpoints. Check the current documentation before assuming that every image URL, file reference or media type supported elsewhere will work here.

What changed from the earlier preview?

The biggest change on October 6 is access. Earlier coverage still described the Decisions API as limited or invitation-only. OpenAI’s new announcement explicitly says it is available to all developers in public beta.

That freshness gap matters: older articles can still rank while telling readers they cannot use the endpoint. Developers searching today should rely on the public-beta announcement rather than pre-release access reports.

Beta caveats

• The endpoint is still a beta and schemas, limits or pricing can change.
• Only GPT-6 Luna is listed as the model at launch.
• Latency claims are task-dependent.
• Confidence values require calibration and testing for your domain.
• High-stakes decisions should include appropriate safeguards and human review.

FAQ

Is the OpenAI Decisions API available now?

Yes. OpenAI announced public beta access for all developers on October 6, 2026.

What endpoint does it use?

The dedicated endpoint is POST /v1/decisions.

Which model powers it?

At public-beta launch, OpenAI lists gpt-6-luna as the supported model.

What outputs can it return?

Predicates, fixed choices and ordered scores.

Does it support images?

Yes. OpenAI says the API can evaluate text, images or both.

Is it a replacement for the Responses API?

No. It is optimized for bounded decisions. Use Responses API when you need generated content, custom structured objects, tool calls or broader agent behavior.

Bottom line

The Decisions API gives developers a purpose-built classifier and scorer instead of forcing every workflow through open-ended generation. Its public-beta availability, dedicated /v1/decisions endpoint, typed outputs and speed claim make it a strong fit for routing and triage. The main caution is simple: it is still a beta, so verify current pricing, request schemas and limits before locking them into production.