OpenAI Decisions API Hands-On Analysis: Zero Output Cost, Where the Savings Come From

OpenAI has launched an API with a rather counterintuitive pricing model. According to an announcement posted on the OpenAI developer forum on October 6, 2026, the Decisions API has officially entered public beta — it does not generate text, it only returns "decisions," and output token billing is $0. Developers submit text or images, and the endpoint returns a probability value, a choice, or a score, with billing calculated solely on input.

This pricing model deserves careful dissection, because its cost structure could change how a whole class of classification and routing workloads are built. At the same time, OpenAI's accompanying "10x faster" claim currently lacks verifiable benchmark data and needs to be evaluated separately.

What the Decisions API Actually Returns

The new standalone endpoint is POST /v1/decisions. Developers define the question, and the API returns one of three typed results:

• Predicate: a 0-to-1 probability that a condition is true, e.g., "is this message urgent"
• Choice: one item selected from a fixed list, with a confidence score, e.g., "route to: billing/support/logistics/account"
• Score: a rating on an ordered severity scale

The return value contains no parseable natural language. In the traditional approach, the model would output "this looks like a billing-related question, so I suggest..." and then code would need regex to turn that into an executable action. The Decisions API eliminates this step — the answer is structured by nature.

The endpoint currently supports only one model, gpt-6-luna. Input can be text, images, or a mix of both, but images must be provided as base64 inline data URLs (up to 128 per request); hosted image links and uploaded file IDs are rejected.

The Math on Input Billing

Public pricing is:

• Input: $0.10 / 1M tokens
• Output, cache reads, cache writes: all $0

For comparison, calling gpt-6-luna through the regular endpoint costs $0.10 per 1M input tokens and $0.50 per 1M output tokens. For classification-type workloads — where the answer is a label rather than a long passage — output cost has historically been the part that rubs salt in the wound. The Decisions API wipes it out entirely.

One analysis concludes that for short-answer classification scenarios, the cost is roughly one-fifth of standard Luna pricing. The exact savings depend on the input-to-output ratio, but the direction is clear: if your LLM call only returns a three-token verdict, you've been paying for things you don't need.

OpenAI's own documentation leaves two variables to watch: regional processing surcharges and long-context input multipliers, neither of which has a published figure. You should model costs based on your real traffic rather than copying the headline price.

What a token is, and why input/output billing is asymmetric

A token is the smallest unit of text the model processes, roughly corresponding to part of an English word or a single Chinese character. API billing typically splits tokens into "input" (the prompt, context, and image encoding you send to the model) and "output" (the text the model generates). The reason output unit pricing is generally higher than input is that input can be processed in parallel — one forward computation suffices — whereas output must be generated autoregressively token by token: each generated token requires re-running the network, with the already-generated content fed back in as the next step's input. This makes the per-unit compute cost of output far higher than that of input. For classification tasks, the output is often just one or two label tokens, yet it's precisely these few tokens that determine whether the whole call is expensive. By zeroing out output pricing, the Decisions API is essentially acknowledging that for this class of task, the computational bottleneck lies in reading the input, not generating the answer.

The 10x Speed Claim Needs Verification

In its launch materials, OpenAI says Decisions returns answers "about 10 times faster than the Responses API." But this figure comes with no benchmark, no per-call compute disclosure, and no accuracy comparison between /v1/decisions and calling the same gpt-6-luna model through the Responses API.

Faster makes intuitive sense: skipping autoregressive text generation and directly outputting a typed scalar should require less compute. But "10x faster" presupposes: at what accuracy? An API that quickly returns a wrong decision is worse than a slow but correct one. OpenAI's own guidance is to set thresholds using your labeled samples — which is really a polite way of saying "please verify this yourself."

Until someone publishes reproducible data, treat 10x as a marketing claim. The pricing, at least, is arithmetic you can check.

The Boundary Between Decisions, Structured Outputs, and Function Calling

OpenAI's official guide draws three lines:

• Decisions API: you need a verdict — classification, routing, scoring, gating. The answer itself is the output.
• Structured Outputs (Responses API): you need to extract fields or written explanations, while also requiring structure.
• Function calling: you need the model to trigger a tool with parameters.

A practical rule of thumb: if you're writing prompts like "reply with only the word billing," then still stripping whitespace and lowercasing — that is essentially a Decisions API call dressed up in Chat Completions clothing. Migrate what should be migrated.

What Structured Outputs and function calling each solve

Structured Outputs constrains what the model generates to conform to a given JSON Schema, suitable for scenarios where you want "both text and fields," such as extracting Party A, Party B, and the amount from a contract. It still generates text — only the format is forced into compliance. Function calling (Function Calling / Tool Use) instead lets the model decide "whether an external tool needs to be called" and provides the tool name and parameters, with your code executing the actual action. The difference among the three lies in the semantics of the output: Decisions returns the verdict itself (a probability, a choice, a score), Structured Outputs returns content that has been structured, and function calling returns an instruction for "what to do next." If you only need a label, using Structured Outputs or function calling means paying for text generation you don't need.

Where It Fits and Where It Doesn't

Good fit:

• Content moderation and triage queues (classification → routing → action)
• Agent tool routing: turning "which tool handles this request" into a typed selection
• Any pipeline that currently has the LLM return a label and then parses it in code
• Compliance-sensitive workflows — it supports Zero Data Retention, is HIPAA-eligible, and offers US/EU data residency options, making it a reasonable replacement for gating workflows that previously strung together JSON schema prompts on top of Chat Completions

Watch out for:

• Still in public beta; general availability (GA) is "coming in the next few weeks," with no fixed date
• A single model (gpt-6-luna), with no fallback if Luna underperforms in your domain
• Image input is inline only; if your pipeline relies on hosted URLs, you'll need to add a fetch-and-encode step
• Regional and long-context multipliers are undisclosed; model costs based on measured traffic

What Zero Data Retention, HIPAA, and data residency mean

Zero Data Retention (ZDR) means the provider commits not to store request and response content on its servers, discarding it once processing is complete, typically requiring a separate application and signed agreement. HIPAA is the US Health Insurance Portability and Accountability Act; only providers that have signed a Business Associate Agreement (BAA) can handle protected health information, so "HIPAA-eligible" means healthcare organizations can compliantly send requests containing patient data. Data Residency refers to which geographic region data is processed and stored in; the US/EU options exist to satisfy restrictions on cross-border transfers under regulations like GDPR. For compliance-sensitive gating and triage workflows, these attributes are often more critical than price, and they are one of the main advantages of the Decisions API over "rolling your own JSON prompt."

The Bigger Pattern: The LLM Is Being Unbundled

The Decisions API is a step in OpenAI unbundling the LLM. For years the industry sold a single primitive — "generate text" — and developers cobbled together classifiers, routers, and scorers with prose plus parsing. Now the primitive is differentiating: use text generation when you need text, use typed decisions when you need decisions, each priced according to its actual cost of service.

Anthropic made the same split from the other direction that same month: Haiku 5.5 aimed at high-throughput scenarios, Opus 5.5 aimed at frontier reasoning. The era of one model doing everything is winding down. The real winners will be the teams that can route each call to the cheapest primitive that suffices.

Summary

The Decisions API (public beta October 6, 2026) offers POST /v1/decisions, returning a probability, choice, or score instead of prose; pricing is $0.10 per 1M input tokens and $0 for output; the "10x faster" claim has no independent verification and requires validating accuracy on your own labeled data; use it when the answer is a verdict, and keep Structured Outputs when you need explanation plus structure. Beta caveats: single model, inline images only, undisclosed regional multipliers.

Speed and accuracy claims come from OpenAI official sources; no independent benchmarks were found as of writing.

One-line Summary

OpenAI launches the Decisions API, which returns only typed decisions with free output tokens, now in public beta.

Paragraph Summary

On October 6, 2026, OpenAI opened the Decisions API to public beta. Through POST /v1/decisions it returns one of three typed results — predicate probability, choice, or score — without generating any natural language. Pricing is $0.10 per million input tokens, with output, cache reads, and cache writes all free, making classification scenarios roughly one-fifth the cost of standard calls. OpenAI claims it is about 10x faster than the Responses API, but there are no benchmarks, compute disclosures, or accuracy comparisons, so you need to verify it yourself. The endpoint currently supports only the single model gpt-6-luna, accepts images only as base64 inline URLs (up to 128 per request), and has not published regional processing surcharges or long-context multipliers. The article frames this as a step in unbundling the LLM primitive, and recommends migrating calls that only need a verdict away from chat-style interfaces.