OpenAI Decisions API: GPT-6 Luna Pricing, Examples & Decisions API vs Responses API

OpenAI has launched a new API designed for a task that many developers currently solve with full language-model responses:

making fast, structured decisions.

The new:

Decisions API

uses GPT-6 Luna to evaluate text, images or both and return one of three specialized answer types:

• a probability that something is true;
• a choice from a fixed set of options; or
• a score against an ordered rubric.

OpenAI says the Decisions API can perform these tasks approximately:

10× faster than using GPT-6 Luna through the Responses API

for comparable decision workloads.

Pricing is also unusual.

OpenAI currently charges:

$0.10 per million input tokens

for standard short-context Decisions API usage.

There are:

no output-token charges

no cache-read charges

and:

no cache-write charges

for the /v1/decisions endpoint.

The API entered public beta on:

October 6, 2026

and currently supports only:

gpt-6-luna

Here is how the OpenAI Decisions API works, what it costs, when it makes sense to use it and how it differs from the Responses API.

OpenAI Decisions API at a Glance

Feature	Decisions API
Release date	October 6, 2026
Status	Public beta
Endpoint	POST /v1/decisions
Current model	gpt-6-luna only
Text input	Yes
Image input	Yes
Predicate output	Yes
Choice output	Yes
Score output	Yes
Standard input price	$0.10 / 1M tokens
Output-token charge	$0
Cache-read charge	$0
Cache-write charge	$0
Speed claim	About 10× faster than Responses API for decision tasks
ZDR support	Yes, for eligible customers
HIPAA support	Yes, for eligible customers
US data residency	Supported
European data residency	Supported for eligible customers

Official documentation:

OpenAI — Decisions API

What Is the OpenAI Decisions API?

The Decisions API is a specialized OpenAI endpoint for applications that need the model to:

decide

rather than:

write.

A normal generative AI request might ask:

Explain whether this customer message is urgent.

The model could return several paragraphs.

But many applications do not need an explanation.

They simply need:

Urgent: Yes

or:

Urgency probability: 0.94

That is the kind of workload the Decisions API is designed for.

OpenAI specifically identifies uses such as:

• classifying content;
• routing requests;
• prioritizing work;
• determining whether a condition is true;
• selecting among known categories; and
• scoring an item against defined criteria.

Why OpenAI Created a Separate Decisions API

Large language models are frequently used as classifiers.

For example, companies use AI to determine:

• which customer-support department should receive a message;
• whether an invoice belongs to a certain category;
• whether an image contains visible damage;
• how severe a technical issue is;
• whether a document is relevant to a search;
• which AI model should handle a request;
• whether human review is necessary.

Traditionally, developers might send these tasks through the Responses API and ask the model to generate structured JSON.

That works.

But it can be unnecessarily expensive and slow when the application needs only:

one decision.

The Decisions API creates a specialized path for those workloads.

GPT-6 Luna Powers the Decisions API

At launch, the only supported model is:

gpt-6-luna

OpenAI describes GPT-6 Luna as its most efficient GPT-6 model for focused, high-volume workloads.

Luna normally supports:

• 1.05 million tokens of context;
• text input;
• image input;
• 128K maximum output;
• reasoning;
• structured outputs;
• function calling; and
• multiple agent tools through the Responses API.

For the complete model guide, see our GPT-6 Luna pricing, features and context window article.

The Decisions endpoint uses Luna differently.

Instead of asking Luna to generate arbitrary text, you define:

specific questions

and:

specific answer types.

The Three Decisions API Output Types

The Decisions API currently supports three major question types:

1. Predicate
2. Choice
3. Score

Each serves a different purpose.

1. Predicate: Is Something True?

A predicate evaluates whether a condition is true.

The API returns a:

probability between 0 and 1.

For example:

Does this product image show visible damage?

Possible result:

0.91

That means the model estimates a 91% probability that the condition is true.

Other possible predicate use cases include:

• Does this message request a refund?
• Is this document relevant to the query?
• Does the image contain visible damage?
• Does the support ticket require human review?
• Is this text discussing billing?

Predicates are useful when your application ultimately needs a:

yes/no decision

but you also want access to confidence information.

Predicate Probability vs. Boolean

The Decisions API does not simply return:

true

or:

false.

It returns a probability.

That lets developers define their own thresholds.

For example:

0.90+ → automatically approve

0.60–0.89 → send for human review

below 0.60 → reject

The correct thresholds depend on your application.

OpenAI recommends testing decisions against labeled examples and choosing thresholds based on the cost of:

• false positives; and
• false negatives.

2. Choice: Pick One Option

A choice question asks GPT-6 Luna to select from a fixed list.

For example, suppose a customer says:

I was charged twice for my order.

Your choices might be:

• billing;
• technical support;
• shipping;
• account access;
• other.

The Decisions API could return:

billing

along with confidence and probability information.

This makes choice particularly useful for:

• customer-support routing;
• document classification;
• intent detection;
• lead categorization;
• request routing;
• workflow selection; and
• choosing among AI models or tools.

Choice Is Best for Unordered Categories

Use choice when the available options do not have a natural numerical order.

For example:

Billing

Shipping

Technical

Account

Those are categories.

One is not inherently greater than another.

3. Score: Rate Something Against a Rubric

A score question works differently.

You define ordered levels.

For example:

0 — Cosmetic

1 — Workaround available

2 — Fully blocked

The model evaluates the evidence and returns probabilities for each level.

It then calculates a:

probability-weighted score.

Because it is weighted, the result can fall between levels.

For example:

1.3

could indicate a problem somewhere between:

workaround available

and:

fully blocked.

Score Use Cases

Scoring can be useful for:

• technical-issue severity;
• lead quality;
• document relevance;
• risk ranking;
• customer priority;
• content quality;
• damage severity;
• escalation priority; and
• support-ticket urgency.

The important difference is that score levels should represent a genuine ordered scale.

Decisions API Pricing

The pricing model is particularly simple.

For standard short-context GPT-6 Luna usage:

Input: $0.10 per million tokens

OpenAI says you pay only for input tokens.

There are:

no output-token charges

no cache-read charges

and:

no cache-write charges

on the Decisions endpoint.

That differs from normal GPT-6 Luna API calls.

GPT-6 Luna Normal API Pricing

For comparison, standard short-context GPT-6 Luna usage through normal model endpoints is listed at:

Input: $0.10/M

Cached input: $0.01/M

Cache write: $0.125/M

Output: $0.50/M

The Decisions API therefore uses the same standard uncached input price but eliminates the normal output-token cost.

Example Cost: 1 Million Input Tokens

Suppose your application processes exactly:

1,000,000 input tokens

through the Decisions API.

Base cost:

1 × $0.10 = $0.10

That is:

10 cents

for one million standard short-context input tokens.

There is no additional output-token charge.

Example Cost: 100,000 Decisions With 500 Tokens Each

Suppose each classification request contains:

500 input tokens

and your application processes:

100,000 requests.

Total input:

500 × 100,000 = 50,000,000 tokens

That equals:

50 million tokens.

Cost:

50 × $0.10 = $5

So the simplified token cost would be:

$5

for 100,000 classification requests of 500 input tokens each.

This excludes any applicable regional or long-context pricing adjustments.

Long-Context Pricing Still Applies

The headline:

$0.10/M

rate does not necessarily apply to every possible request length.

OpenAI says:

long-context input pricing multipliers apply

to the Decisions API.

GPT-6 Luna’s normal model pricing increases when input exceeds:

272,000 tokens.

OpenAI currently lists long-context Luna input pricing at:

$0.20 per million tokens

under standard processing.

So applications working with extremely large documents should account for the higher input rate.

Regional Processing Can Cost More

OpenAI also states that regional processing premiums apply where relevant.

Its current GPT-6 Luna pricing lists a:

10% regional-processing premium

for eligible data-residency processing.

Check current OpenAI pricing before estimating production costs.

Why No Output-Token Charge?

The Decisions API does not generate conventional long-form model responses.

Instead, it returns typed decision data.

That means applications avoid paying for lengthy generated explanations when they only need something like:

billing

or:

0.87 probability

or:

severity score 1.3.

This is one of the main economic advantages of the endpoint.

Decisions API vs Responses API

Here is the practical comparison.

Feature	Decisions API	Responses API
Main purpose	Fast typed decisions	General AI generation and agents
Current model	GPT-6 Luna	Many models
Text input	Yes	Yes
Image input	Yes	Yes
Arbitrary text generation	No	Yes
Predicate	Native	Can be built manually
Choice	Native	Can be built with Structured Outputs
Score	Native	Can be built manually
Function calling	Not the primary design	Yes
Built-in tools	Not the primary design	Yes
Custom JSON schema	Limited to decision types	Structured Outputs supported
Output-token charge	No	Yes
Speed for decision tasks	About 10× faster	General-purpose
Best for	Classification/routing/scoring	Generation, agents, tools, workflows

When Should You Use Decisions Instead of Responses?

Use the Decisions API when your application needs:

a small typed answer

rather than:

generated content.

Good examples:

• choose a department;
• classify a document;
• detect a condition;
• rank severity;
• estimate relevance;
• choose a workflow;
• prioritize a queue;
• determine whether human review is necessary.

When Should You Use Responses Instead?

Use the Responses API when you need:

• generated explanations;
• summaries;
• essays;
• emails;
• code;
• custom JSON objects;
• tool use;
• function calls;
• web search;
• file search;
• computer use;
• image generation;
• multi-step agent workflows.

OpenAI specifically recommends Structured Outputs with the Responses API when you need a custom JSON object.

Decisions API Is Not a Replacement for Structured Outputs

Suppose you need to extract:

• customer name;
• invoice number;
• due date;
• amount;
• billing address.

That is not simply a decision.

It is:

structured extraction.

The Responses API with Structured Outputs is usually a better fit.

But suppose you need to answer:

Is this document an invoice, receipt or contract?

That is a perfect:

choice

problem.

Decisions API Is Not a Replacement for Function Calling

Suppose your application needs the model to decide to call:

refund_customer(order_id)

and generate the correct function arguments.

That is a tool-use workflow.

Use function calling through the Responses API.

The Decisions API is better when your application itself will handle the action after receiving the model’s decision.

Example: Customer Support Routing

Imagine your business receives:

50,000 customer messages per day.

Instead of asking a full model to generate a response to every message immediately, you could first classify each request.

Possible choices:

• billing;
• technical;
• shipping;
• cancellation;
• account access;
• other.

The Decisions API could perform the routing.

A separate AI agent or employee could then handle the message.

That can reduce unnecessary use of larger models.

Example: AI Model Routing

The API could also help choose which model receives a request.

Suppose your application has:

• GPT-6 Luna;
• GPT-6.1 Sol; and
• GPT-6 Astra.

A choice question might classify the request as:

• simple;
• moderate;
• complex.

Then your software could route:

simple → Luna

moderate → Sol

complex → Astra

This can reduce AI costs by avoiding the most expensive model when it is unnecessary.

For a broader cost comparison, see our Best Cheap AI Models in 2026 guide.

Example: Lead Scoring

A sales system could define:

0 — Low priority

1 — Medium priority

2 — High priority

The Decisions API could evaluate an inbound lead against those criteria and return a score.

Your CRM could then:

• route high-priority leads to sales;
• put medium leads into nurture;
• deprioritize low-quality inquiries.

Example: Image Damage Detection

The API supports images.

OpenAI’s documentation gives the example of checking a product image for:

• cracks;
• tears; or
• dents.

A predicate question could return the probability that visible damage exists.

This could be useful in:

• ecommerce returns;
• insurance intake;
• warehouse inspection;
• quality control;
• delivery claims.

Image Input Has an Important Limitation

At launch, Decisions API image inputs must use:

inline base64 data URLs.

OpenAI says the endpoint currently does not support:

• hosted HTTP image URLs; or
• file_id image inputs.

That is an important implementation detail for developers migrating from other OpenAI APIs.

You Can Ask Multiple Questions in One Request

The Decisions API allows several:

independent questions

to evaluate the same input.

For example, given a product photo you could ask:

1. Is the product damaged?
2. What product category is it?
3. How severe is the damage?

Each question could use a different decision type.

This avoids sending the same shared input multiple times when the questions are independent.

Dependent Decisions Require Separate Requests

There is an important limitation.

If question two depends on the answer to question one, OpenAI recommends using:

separate requests.

For example:

First:

Is the product damaged?

Then only if the answer is yes:

What repair category applies?

Do not assume the questions array provides arbitrary branching logic.

Confidence and Probabilities Matter

The Decisions API is more useful when you treat outputs as:

probabilistic

rather than:

perfect answers.

For choice and score questions, OpenAI returns probability information and confidence.

That makes it possible to design human-review thresholds.

For example:

Confidence ≥ 0.95 → automatic routing

0.70–0.94 → normal workflow

below 0.70 → human review

The exact thresholds should be determined through testing.

Test With Real Labeled Data

OpenAI recommends evaluating the API against labeled examples from your application.

This is essential.

A routing system for:

customer support

may need very different thresholds from one used for:

financial document review.

Measure:

• false positives;
• false negatives;
• misclassification cost;
• human-review rate;
• latency; and
• per-decision cost.

Decisions API and AI Agents

The Decisions API could become particularly useful inside agent systems.

An agent frequently needs to answer small questions such as:

• Which tool should I use?
• Which workflow applies?
• Is this request risky?
• Which specialist agent should handle this?
• Is this document relevant?
• How urgent is this issue?

Using a full generative call for every small routing step can be expensive.

The Decisions API gives developers a specialized low-cost decision layer.

For practical agent examples, see our AI Agents for Small Business guide.

Decisions API and GPT-6 Luna Economics

GPT-6 Luna was already designed for high-volume AI workloads.

The Decisions API makes that positioning even clearer.

A business could potentially use Luna through Decisions for:

• classification;
• routing;
• filtering;
• scoring;

then escalate selected requests to more capable models.

This creates a layered architecture:

Decisions API → route

GPT-6 Luna → focused task

GPT-6.1 Sol → harder task

GPT-6 Astra → most difficult work

The goal is not simply choosing the cheapest model.

It is choosing the cheapest system that reliably completes each part of the workflow.

Decisions API Endpoint

The dedicated endpoint is:

POST /v1/decisions

The model is currently:

gpt-6-luna

A request contains three main parts:

• model
• input
• questions

The input provides the evidence.

The questions specify what decisions should be made.

Simple Decisions API Example

A customer says:

I was charged twice for my order.

Your application could ask which department should handle the request.

{
  "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."
        }
      ]
    }
  ]
}

The API could return:

billing

along with confidence and probability data.

Is the Decisions API Faster Than GPT-6 Luna Normally?

OpenAI says:

yes, for decision-style workloads.

Its documentation describes Decisions as returning typed answers about:

10× faster than the Responses API.

This does not mean the Decisions API is 10× faster for every possible GPT-6 Luna task.

It is a specialized comparison for workloads the Decisions endpoint is designed to handle.

If you need a 2,000-word article, Decisions is not the correct API.

If you need:

billing vs technical vs shipping

it may be.

Does Decisions API Support Images?

Yes.

You can combine:

• text; and
• image input.

That makes it useful for multimodal classification.

However, remember the current base64-only image-input requirement.

Does Decisions API Support Audio?

OpenAI’s current Decisions documentation describes:

text and image input.

Audio is not listed as an input modality for the Decisions endpoint.

Does Decisions API Support Tools?

The Decisions API is not positioned as the endpoint for web search, function calling, file search or computer use.

OpenAI directs developers toward the Responses API when those capabilities are needed.

Does It Support Multiple Models?

Not currently.

At launch, only:

gpt-6-luna

is available.

That may change as the API moves beyond beta, but developers should not assume support for GPT-6.1 Sol or GPT-6 Astra today.

Is Decisions API Production Ready?

The API is currently:

public beta.

OpenAI says it expects general availability in the coming weeks.

Public beta means developers can use and test it, but production teams should watch for:

• API changes;
• new model support;
• updated limits;
• pricing changes; and
• GA documentation.

Zero Data Retention Support

OpenAI says the Decisions API supports:

Zero Data Retention

for eligible customers.

That can be important for companies with strict data-governance requirements.

Eligibility and contractual requirements still apply.

HIPAA Support

OpenAI also says Decisions can support:

HIPAA use for eligible customers.

That does not mean every API account automatically becomes HIPAA compliant.

Organizations still need the required agreements and configuration.

Data Residency

OpenAI lists regional-processing and data-residency support for eligible customers in:

United States

and:

Europe — EEA plus Switzerland

Regional-processing premiums may apply.

Decisions API Advantages

The strongest advantages are:

• extremely low cost;
• no output-token charge;
• roughly 10× faster decision workloads;
• native probability outputs;
• text and image input;
• purpose-built classification;
• routing;
• prioritization;
• scoring;
• multiple independent questions per request;
• GPT-6 Luna efficiency;
• ZDR eligibility; and
• HIPAA eligibility for qualifying customers.

Decisions API Limitations

Important limitations include:

• only GPT-6 Luna is supported today;
• public-beta status;
• only three specialized decision types;
• no arbitrary long-form generation;
• no custom free-form JSON schema like Responses Structured Outputs;
• not designed for tool execution;
• image inputs currently require inline base64;
• dependent questions require separate requests;
• probabilistic outputs still require evaluation and threshold tuning.

Who Should Use the Decisions API?

It is particularly attractive for developers building:

Customer support

Route tickets and estimate urgency.

AI agents

Choose tools, workflows or specialist agents.

Ecommerce

Classify products or inspect images.

SaaS products

Categorize support and feature requests.

Document systems

Classify document types or relevance.

Sales systems

Prioritize and score leads.

Operations teams

Estimate severity and route incidents.

Large-scale AI applications

Reduce latency and token costs for repetitive decision steps.

Who Should Keep Using Responses API?

Stay with Responses when you need:

• natural-language generation;
• rich explanations;
• tool calls;
• structured extraction;
• coding;
• research;
• web search;
• computer use;
• long-form content;
• multi-step agent work.

The two APIs are complementary.

Decisions API vs Cheap AI Model Prompting

Developers sometimes solve classification by simply prompting a cheap model:

Reply with only billing, shipping or technical.

That can work.

But the Decisions API provides:

• explicit typed outputs;
• probability distributions;
• confidence information;
• specialized scoring;
• no output-token charge; and
• lower latency for the targeted workload.

For high-volume applications, those differences can matter.

Frequently Asked Questions

What is OpenAI Decisions API?

It is a specialized API for evaluating text or images and returning typed decisions such as predicates, fixed choices and rubric scores.

When was Decisions API released?

OpenAI released it in public beta on:

October 6, 2026.

Which model does it use?

Currently:

gpt-6-luna

How much does Decisions API cost?

Standard short-context input costs:

$0.10 per million tokens.

OpenAI says there are no output-token, cache-read or cache-write charges for /v1/decisions.

Is it cheaper than Responses API?

For decision workloads, it can be, particularly because there is no normal GPT-6 Luna output-token charge.

Is it faster?

OpenAI says the Decisions API returns typed decisions approximately 10× faster than the Responses API for comparable workloads.

What outputs does it support?

Three types:

predicate

choice

and:

score

Does it support images?

Yes.

Can I submit image URLs?

OpenAI currently requires inline base64 image data. Hosted image URLs and file_id inputs are not supported by the endpoint.

Can I ask multiple questions?

Yes, if they are independent.

Can one question depend on another?

OpenAI recommends separate requests when later decisions depend on earlier answers.

Does it support tools?

Use the Responses API when you need function calling or built-in tools.

Does it replace Structured Outputs?

No.

Use Responses Structured Outputs when you need a custom JSON schema rather than a predicate, choice or score.

Is it generally available?

Not yet.

It is currently in public beta.

Does it support HIPAA workloads?

OpenAI says HIPAA use is supported for eligible customers, subject to applicable requirements and agreements.

OpenAI’s Decisions API gives developers a specialized alternative to using a general-purpose language-model response for every classification or routing problem.

It currently uses:

GPT-6 Luna

and supports three output types:

Predicate → probability something is true

Choice → select one predefined option

Score → evaluate against ordered levels

For standard short-context input, pricing starts at:

$0.10 per million input tokens

with:

no output-token charge

and no cache-read or cache-write charges.

OpenAI says decision workloads can run approximately:

10× faster

than using GPT-6 Luna through the Responses API.

That makes the API especially interesting for:

• routing;
• classification;
• triage;
• scoring;
• AI-agent orchestration;
• support automation; and
• high-volume decision pipelines.

The Decisions API is not a replacement for the Responses API.

A simple way to think about the difference is:

Need the AI to write or act? → Responses API

Need the AI to choose, classify or score? → Decisions API

For developers building large-scale AI systems, that separation could reduce both latency and cost.

Related Reading on Elite Era Trends

What Is GPT-6 Luna? Pricing, Features & Context Window

Best Cheap AI Models in 2026