OpenAI's Decisions API: GA pricing, limits, and when to skip it

OpenAI's Decisions API went generally available on October 22, 2026, and the thing most teams will get wrong isn't the request shape. It's the pricing. The headline rate is $0.10 per 1M input tokens on gpt-6-luna, per OpenAI's Decisions guide, and that number is true and also incomplete: cache writes now cost more per token than a plain uncached call, because GA introduced prompt caching as a new feature the beta never had.

The request shape is the easy part, and it hasn't changed much since the October 6 beta. What changed at GA is worth a careful read before you point production traffic at it: the question cap doubled, JSON input landed, and the pricing model picked up a wrinkle that doesn't show up if you only skim the headline rate.

What the endpoint actually does

POST /v1/decisions takes three things: a model (only gpt-6-luna is supported), an input (text, images, JSON, or a conversation history), and a questions array. Each question is one of three types, per the GA guide:

• predicate returns a probability from 0 to 1 that a stated condition is true. ("Does this photo show visible damage?")
• choice picks one value from a fixed list and returns a confidence plus a probability for every option. ("Which department handles this ticket?")
• score rates input against 2 to 10 ordered levels and returns the probability-weighted average of the level indices, so the result can land between levels. ("How severe is this bug?")

Here's a minimal request that routes a support complaint by department:

curl https://api.openai.com/v1/decisions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "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 response is a flat answers array keyed by the name you gave each question, not a text blob you still have to parse:

{
  "answers": [
    {
      "type": "choice",
      "name": "department",
      "choice": "billing",
      "probabilities": [
        { "value": "billing", "probability": 0.95 },
        { "value": "technical", "probability": 0.02 },
        { "value": "shipping", "probability": 0.01 },
        { "value": "other", "probability": 0.02 }
      ],
      "confidence": 0.93
    }
  ]
}

No output tokens get billed on any question type, per the GA guide's pricing section. That's the real pitch: a classification call that doesn't make you pay for the JSON it would otherwise generate, and doesn't make your code parse that JSON either.

What's new at GA, and what it costs

OpenAI's October 22 changelog entry lists the beta-to-GA delta directly, and it's bigger than a status change, per the changelog:

• The per-request question cap rose from 200 to 400.
• input_json lets you pass structured data (a support ticket plus an order record, say) as a content part instead of stringifying it first.
• Questions can now carry their own input_image parts in instructions, so one request can compare several candidate images against one shared reference.
• Prompt caching arrived, keyed on the shared input, not the per-question instructions.

That last item is the one that changes your cost model. In beta there was no caching at all. GA's pricing table for gpt-6-luna short-context calls breaks out four separate rates, per OpenAI's pricing page:

Token type	Rate per 1M tokens	Source
Uncached input	$0.10	OpenAI pricing page, gpt-6-luna short context, fetched Oct 25, 2026
Cached input (cache hit)	$0.01	OpenAI pricing page, gpt-6-luna short context, fetched Oct 25, 2026
Cache write, 30-minute TTL	$0.125	OpenAI pricing page, gpt-6-luna short context, fetched Oct 25, 2026
Cache write, 12-hour TTL	$0.25	OpenAI pricing page, gpt-6-luna short context, fetched Oct 25, 2026
Output (any question type)	$0	Decisions API guide, Pricing and availability

A cache hit is ten times cheaper than a cold call. But a cache write costs more per token than just sending the request uncached in the first place, up to 2.5x the base rate for a 12-hour TTL. If your input changes on every call (a different support ticket each time, say), you get no cache hits and you're paying the write surcharge on top of the base rate for nothing. Decisions places an implicit cache breakpoint at the end of shared input by default, and the reusable prefix needs at least 1,024 tokens before it even qualifies, per the GA guide. A short ticket body won't hit that floor. Caching pays off specifically when you hold a large, stable reference (a product catalog, a policy document, a set of comparison images) in input and vary only the questions across calls. If your workload doesn't look like that, ignore caching and budget the flat $0.10 rate.

Decisions API vs. rolling your own on Responses

The question most teams actually have isn't "how do I call this." It's "should I use this instead of a Structured Outputs call against the Responses API, which I already know how to use." The answer depends on what shape your answer needs to be.

	Decisions API	Structured Outputs (Responses API)	Function calling
Returns	A typed probability, choice, or score	Any JSON object matching your schema	A tool-call request with arguments
Output tokens billed	No	Yes	Yes
Model choice	gpt-6-luna only	Any Responses-compatible model	Any Responses-compatible model
Best for	Routing, moderation, severity triage: narrow, bounded answers	Extracting fields, generating a structured document, free-form reasoning in a shape	Letting the model decide to invoke a tool with arguments
Questions per call	Up to 400	1 (one schema per call)	As many tools as you expose

OpenAI draws this line itself in the GA guide: reach for Structured Outputs when you need a generated object with your own schema (extracted fields, a written explanation), and for function calling when a model needs to request a tool call with arguments. Decisions is deliberately narrower, per the GA guide. If your "structured output" is actually just a single enum field wrapped in a JSON schema, you've been paying for generated output tokens to produce something Decisions gives you for free. If you need three extracted fields and a two-sentence summary, Decisions can't do that in one call and Structured Outputs is still the right tool.

The limits that will actually bite

A few constraints are easy to miss in the headline GA announcement:

• One model, period. gpt-6-luna is the only model Decisions runs on. You don't get to trade accuracy for cost by stepping up to a bigger model the way you can on Responses.
• One request can't depend on an earlier answer in the same call. If you need to check for damage first and only then classify a repair category, that's two sequential requests, not one with 400 questions, per the GA guide.
• No file_id inputs. Images go in as inline base64 data URLs or public HTTP/HTTPS URLs. If your images live behind an API that OpenAI's servers can't reach, you base64-encode them yourself first.
• ZDR and HIPAA are available for eligible customers, with regional processing limited to the US and EEA/Switzerland, per the GA guide. If your compliance posture requires a specific region outside those two, Decisions doesn't cover you yet.
• Usage reporting counts requests, not questions. GET /v1/organization/usage/decisions reports num_model_requests per call, so a 400-question request shows up as one request in your dashboard even though you're paying for the tokens of all 400, per the GA guide.

When it's worth wiring up

Worth it when your application is making a chat-completion call purely to get a yes/no, a category, or a severity level back, and then throwing away everything except that one value. That's the exact waste Decisions is built to cut: you stop paying for and parsing prose you never show anyone. Content moderation gates, support-ticket routing, and image QA checks are the obvious fits, and the 400-question cap means you can batch a lot of those checks into one call against a shared reference image or document.

Not worth it if you need the model to produce something a human reads, or if your "decision" is really a multi-field extraction. In both cases you're going to end up back on Structured Outputs anyway, and adding Decisions as a second code path for a handful of narrow questions isn't worth the maintenance cost unless those questions run at real volume. Check the actual request shape against the Decisions API guide and the pricing page before you commit, since both are the primary source for anything that changes between now and your next invoice.

Watch for third-party evals firms such as Promptfoo and Braintrust to publish independent accuracy comparisons against hand-rolled Structured Outputs classifiers now that GA pricing and the 400-question limit are locked in, per OpenAI's GA changelog entry. That comparison, not the headline price, is what will tell you whether the speed and cost savings hold up in practice.