Decisions API goes GA: a fast, low-cost judgment endpoint, explained

The Decisions API is OpenAI's answer to the cases that need an answer, not a generation: ask structured questions about text, image, or JSON evidence and get typed, probability-bearing answers back. On 2026-10-22 an official announcement made it generally available, and the official guide now documents the full request shape, the three question types, and the pricing. This article lays out every material fact at the GA point in time — announcement wording, guide parameters, the SDK timeline, and the same-day breaking change — each one traceable to a source loaded for this batch.

1. The official wording at GA

The announcement arrived as the official news RSS item of 2026-10-22 19:00 GMT, titled "Build more responsive apps with the Decisions API", with a one-line description: Fast, focused, low-cost decisions for any application (the article page returned 403 to this site that day; the facts here come from the RSS fetch). The substance lives in the official guide, whose opening lines set the frame:

• The Decisions API evaluates text, images, and JSON and returns typed answers about 10x faster than the Responses API. — an officially stated relative speedup ("about 10x") with no absolute latency figures or benchmark methodology attached.
• Send requests to POST /v1/decisions using gpt-6-luna, the only currently supported model. — the endpoint and its single supported model, stated outright.

There is also a Playground at platform.openai.com/decisions for trying questions before writing code.

2. Request and answer shapes

The request has three parts, quoted from the guide's own table:

The response is an answers array; give each question a unique name and the API echoes it back. The three question types:

Both choice and score return probabilities over discrete options plus a separate confidence field. Answer objects also have a refusal type — the official sample code branches on it explicitly. The guide's selection boundary is equally blunt: Structured Outputs for generating objects that follow your own JSON schema, function calling for tool requests, Decisions for typed answers.

3. A complete request (the guide's own example)

This is the support-ticket example from the official guide (an input_json block passes structured evidence inside a user message, no string serialization needed):

{
  "model": "gpt-6-luna",
  "input": [
    {
      "role": "user",
      "content": [
        {
          "type": "input_text",
          "text": "Evaluate the ticket using the order evidence."
        },
        {
          "type": "input_json",
          "data": {
            "ticket": { "body": "Please refund the duplicate charge." },
            "order": { "charges": [49, 49] }
          }
        }
      ]
    }
  ],
  "questions": [
    {
      "type": "predicate",
      "name": "duplicate_charge",
      "instructions": "Does the ticket describe a duplicate charge supported by the order?"
    }
  ]
}

The equivalent SDK call (the official product-photo damage check):

import base64
from openai import OpenAI

client = OpenAI()

decision = client.decisions.create(
    model="gpt-6-luna",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Inspect the product in this photo."},
                {"type": "input_image", "image_url": f"data:image/png;base64,{image_base64}"},
            ],
        }
    ],
    questions=[
        {
            "type": "predicate",
            "name": "visible_damage",
            "instructions": "Does the product have visible damage, such as a crack, tear, or dent? Ignore shadows and damage to the packaging.",
        }
    ],
)

answer = decision.answers[0]
if answer.type == "refusal":
    print(f"Refused: {answer.name}")
elif answer.type == "predicate":
    print(f"Visible damage probability: {answer.probability}")

(In the sample, image_base64 stands for the official example's local-image base64 encoding line and its Path import, compressed here into a variable reference — everything else is quoted verbatim.)

4. What GA adds over the beta

The guide's what's-new section lists nine additions on the way to GA, quoted in order: prompt caching; images in question instructions (each question gets its own images to compare against shared evidence); input_json structured input; the per-request question cap raised from 200 to 400; hosted image inputs (publicly accessible HTTP or HTTPS image URLs alongside inline base64 data URLs); conversation history (messages alongside function and custom tool calls and their outputs, matched by call_id); organization usage reporting (token usage and request counts); native GPT-Live integration (Live calls Decisions directly, or triggers on input/output transcripts); and Private Link.

Conversation history has explicit input boundaries (the guide's table): user messages carry text, images, and JSON; developer or system messages carry input text only, with system treated as developer; assistant messages carry output text or refusals; function or custom tool outputs carry text and images. Files, audio, and item references are not supported.

5. Pricing and compliance boundaries

The guide's Pricing and availability section is this article's only first-party pricing source; the numbers, in order:

• Uncached input with gpt-6-luna costs $0.10 per 1M tokens; cache reads get discounted input pricing and cache writes are charged, at rates matching the standard gpt-6-luna prompt caching rates;
• Output tokens are not charged;
• Regional processing premiums and long-context input pricing multipliers still apply;
• These rates apply only to /v1/decisions — the same model through other endpoints follows the standard model and processing-tier pricing (the standard gpt-6-luna rate is not in this guide and remained unverified in any source loadable by this site as of 2026-10-23);
• Compliance: ZDR and HIPAA support for eligible customers; data residency in all supported API regions; regional processing in the United States and Europe (EEA + Switzerland).

6. The exact caching rules

The guide states the caching semantics outright: by default an implicit cache breakpoint sits at the end of the shared input, so existing requests benefit without changing the request body; the reusable prefix must contain at least 1,024 tokens, and question content does not count toward that threshold; everything inside questions, including question-specific images, sits outside the reusable prefix. Three controls: prompt_cache_key partitions reuse by a caller-provided key; text or image content parts in shared input can carry prompt_cache_breakpoint: {"mode": "explicit"} to mark boundaries; prompt_cache_options.mode set to "explicit" uses only marked boundaries, and a request with none does not use caching at all. Breakpoints are not supported in question instructions. Observability runs through usage.input_tokens_details.cached_tokens and cache_write_tokens — both are already included in usage.input_tokens, so do not add them again.

7. The SDK timeline and the GA-day breaking change

• 2026-10-06 (first beta landing): openai-python v3.26.0 (#4033) and openai-node v7.30.0 (#2886) each merged add standalone Decisions support — identically titled in both packages' release notes.
• 2026-10-16 (caching and Live): v3.32.0 / v7.35.0 added Decisions prompt caching and wired Decisions into Live session triggers (covered in this site's earlier piece, linked under Next steps).
• 2026-10-22 (GA day): python v3.37.0 (#4158, published_at 2026-10-22T20:03:54Z) and node v7.43.0 (published_at 2026-10-22T21:31:14Z) shipped the same breaking change — the Live response's question instructions became string | an array of structured parts (text/image/JSON), so calling string methods on it directly breaks (the node release notes' example: question.instructions.trim()); Decisions request inputs gained new message roles and tool-history items, so exhaustive switches need new branches; and node's DecisionInputMessage became a union, so code extending the old interface must use DecisionInputMessage.DecisionInputUserMessage. The official notes state that existing string instructions and user-message inputs keep working.

8. Next steps

• For the mechanism that triggers Decisions inside Live sessions (triggers, the three question types, delegation), see openai-python 3.32.0 and openai-node 7.35.0: prompt-created voices, Live audio fixtures, and Decisions in Live.
• For gpt-6-luna's official positioning in the GPT-6 family (the low-cost, high-throughput tier), see The GPT-6 family grows: gpt-6-sol, gpt-6-luna, gpt-6.1-sol land in the official SDKs.
• For the overall model-selection framework, see The complete guide to GPT models (2026-07): GPT-5.6 Sol, Terra, Luna.