OpenAI Decisions API Explained: Pricing, Limits, and Use Cases

The OpenAI Decisions API is a General Availability (GA) endpoint on the gpt-6-luna model that returns typed answers for classification and routing tasks. At Layer3Labs, we build custom agents and workflow automation for businesses. OpenAI launched the endpoint on 22 October 2026 after a public beta, at $0.10 per 1M uncached input tokens with output tokens not billed.

The endpoint accepts up to 400 questions against one shared input and evaluates text, images, and JSON in one call.

The service returns probabilities, categorical selections, and numeric scores rather than generated text strings.

What the Decisions API Does and What It Costs

The OpenAI Decisions API provides structured evaluation by running up to 400 questions against a single input payload using gpt-6-luna. OpenAI bills uncached input tokens at $0.10 per 1M tokens, while output tokens are not billed at all. You can review the complete parameter schema on the OpenAI Decisions documentation.

OpenAI describes the endpoint as about 10x faster than the Responses API. It evaluates text, images, and JSON, returning typed responses rather than unstructured paragraphs. Standard gpt-6-luna caching rates apply to cache writes, while cache hits receive discounted input pricing. You can compare base model rates in our gpt-6-luna pricing guide.

Total billing can reflect regional processing premiums and long-context multipliers where applicable. The discounted cache-hit rate is not listed here, so check it on the OpenAI Decisions documentation.

• Uncached input tokens cost $0.10 per 1M tokens on gpt-6-luna
• Output tokens are not billed
• Batch up to 400 questions per evaluation request against one input
• Prompt cache writes follow standard gpt-6-luna rates, while cache hits receive discounts

The Three Supported Question Types

Every question submitted to the endpoint must specify one of three supported question types: predicate, choice, or score. The request payload passes these items inside a top-level questions array, and each item requires a unique name string that OpenAI echoes back in the answers array.

A predicate question assesses whether a condition is true, returning a probability value between 0 and 1.

A choice question selects one value from a list of supplied values. The response object includes a probabilities array across every candidate value and a confidence field. A score question evaluates inputs along 2 to 10 ordered levels, returning a probability-weighted average of the level indices that can fall between discrete integers.

• Predicate: returns a probability value from 0 to 1 that a condition is true
• Choice: selects one discrete option from your array, accompanied by all option probabilities and a confidence score
• Score: calculates a probability-weighted continuous average across 2 to 10 ordered rubric levels

Request Limits and Supported Input Payloads

Requests target the POST /v1/decisions endpoint with three fields: model, input, and questions. The model field only supports gpt-6-luna. The questions array accepts between 1 and 400 questions per request, doubling the beta limit of 200 questions.

The input field accepts a plain text string or an ordered array containing messages, tool calls, and tool outputs. Images are supported through public HTTP or HTTPS URLs, as well as base64 data URLs. Instructions inside individual question objects can also include images.

Files, audio and item references are not supported, and file_id is not accepted for images. input_json parts are accepted in user messages only.

• Model parameter is restricted exclusively to gpt-6-luna
• Request capacity ranges from 1 to 400 questions per payload
• Input arrays accept text, messages, tool calls, and tool outputs
• Images accept base64 strings or public web URLs, but file_id references are not supported

Cost Calculation Against Responses Classifiers

In the illustration below, 10M input tokens cost $1.00 on Decisions and $1.50 on Responses, because Decisions does not bill output. Consider an illustrative workload processing 20,000 classification requests, each containing 500 input tokens, totaling 10M input tokens. This example ignores prompt caching discounts, regional premiums, and long-context multipliers to show the baseline difference.

Under the Decisions API, 10M input tokens billed at $0.10 per 1M tokens generate an input cost of $1.00. Because output tokens are not billed, the final cost for the batch remains $1.00. You can learn more about general model capabilities in our gpt-6-luna guide.

Running the same 20,000 tasks through the Responses API using gpt-6-luna incurs both input and output expenses. The 10M input tokens cost $1.00 at $0.10 per 1M tokens. If each response generates roughly 50 output tokens, the run produces 1M output tokens, which cost $0.50 at $0.50 per 1M tokens, bringing the total expense to $1.50.

• Baseline workload: 20,000 evaluation calls with 500 input tokens each equals 10M input tokens
• Decisions API expense: 10M input tokens at $0.10 per 1M equals $1.00 total
• Responses API expense: 10M input tokens ($1.00) plus 1M output tokens ($0.50) equals $1.50 total
• Multi-question efficiency: asking multiple questions against one input reads the input text once rather than repeating calls

Prompt Caching Rules and Usage Tracking

Your reusable prefix must be at least 1,024 tokens to qualify for prompt caching. Question content does not count toward this 1,024-token minimum requirement.

By default, the system places an automatic cache breakpoint at the end of the shared input payload. The prompt_cache_key parameter partitions cache reuse. If you enable explicit caching mode, the engine uses only the manual breakpoints that you declare.

Tracking usage requires calling the GET /v1/organization/usage/decisions administrative endpoint. This administrative query requires an API key configured with the api.usage.read permission scope. The endpoint returns token usage and request counts, where the num_model_requests field counts total API calls rather than individual question evaluations.

• Shared input prefix must span at least 1,024 tokens to qualify for prompt caching
• Question parameters do not contribute to the 1,024-token caching threshold
• Default configuration places an automatic breakpoint at the end of input data
• prompt_cache_key partitions cache reuse
• GET /v1/organization/usage/decisions reports requests via num_model_requests

Data Residency and Compliance

Zero Data Retention and HIPAA use are supported for eligible customers. Confirm your organization status on the OpenAI Decisions documentation.

Data residency is available in all supported API regions.

Regional processing is supported in the United States and Europe (EEA plus Switzerland). Regional processing premiums apply. Check the amount on the OpenAI Decisions documentation.

• Zero Data Retention supported for eligible customers
• HIPAA use supported for eligible customers
• Data residency available in all supported API regions
• Regional processing boundaries available across the United States and Europe, including Switzerland

When to Choose Decisions Over Responses

Use Decisions when you need typed answers about an input. Use Responses when you need generated content. The Decisions API returns typed evaluations, confidence figures, and categorical labels. If your application needs to generate custom JSON objects adhering to a custom schema, use Structured Outputs on the Responses API.

For tool-call arguments, OpenAI's docs point to function calling with the Responses API.

We would pick Responses over Decisions if OpenAI began billing output tokens or cut the 400-question limit.

• Pick Decisions API: routing, classification, and multi-question evaluation of one input
• Pick Responses API: custom JSON drafting with Structured Outputs, open prose generation, and tool calling
• Ask several questions about the same input in one request, so the input is read once