OpenAI makes the Decisions API generally available: prompt caching, JSON input and up to 400 questions per request

OpenAI's Decisions API is now generally available with gpt-6-luna, on v1/decisions; its API changelog lists the change on 22 October 2026. The same entry names what came with it: you can cache shared input across requests for prompt-cache discounts, include images in individual question instructions, and pass structured data directly withinput_json. And each request now supports up to 400 questions, increased from 200 in public beta. If you send classification, routing or scoring work to this endpoint, the request you already send can benefit from the new cache without a change to its body — but what you pay for it, and how much one request can carry, have both changed.

What changed

The guide now opens by saying the Decisions API is generally available , and it evaluates text, images, and JSON, returning typed answers about 10x faster than the Responses API. You still send requests toPOST /v1/decisions, and gpt-6-luna is still the only supported model.

The guide lists what has been added since the public beta launched :

• Prompt caching— reuse shared input across requests and receive cache discounts.
• Images in question instructions— each question can carry its own images to compare against the shared evidence.
• JSON input — structured data passes directly in an input_jsoncontent part.
• More questions per request— up to 400, up from 200 during the public beta.
• Hosted image inputs— publicly accessible HTTP or HTTPS image URLs as well as inline base64 data URLs.
• Conversation history— messages evaluated alongside function calls, custom tool calls, and their outputs.
• Organization usage reporting— token usage and request counts.
• Native GPT-Live integration— Live can call Decisions directly, or trigger decisions as input or output transcripts arrive.
• Private Link— Decisions requests over a private connection.

The inputfield has grown to match: it is a text string, or an ordered array of messages, tool calls, and tool outputs. Each tool output is matched to its call withcall_id, and files, audio, and item references are not supported.

The pricing section has been rewritten. With gpt-6-luna, uncached input costs $0.10 per 1M tokens. Prompt cache hits receive discounted input pricing, and cache writes are charged , at the same cache-read and cache-write rates as standard gpt-6-luna prompt caching. Output tokens are not charged. Regional processing premiums and long-context input multipliers apply , and these rates are for /v1/decisions only; other gpt-6-luna requests follow the model's own pricing. Zero Data Retention and HIPAA use remain supported for eligible customers. Data residency is now available in all supported API regions , and regional processing in the United States and Europe (EEA and Switzerland).

What it was before

The changelog still carries the beta's own entry: the Decisions API was released in beta with gpt-6-luna on 6 October. Our earlier item,OpenAI releases the Decisions API in beta, quoted the guide as it read then, and three of its lines no longer hold. The pricing section said you paid only for input tokens, with no cache-read, cache-write or output-token charges; it now says cache writes are charged. Images had to be inline base64 data URLs; hosted HTTP or HTTPS URLs are now accepted too , thoughfile_idinputs still are not. And data residency was listed for the United States and Europe only; it now covers all supported API regions. The question limit was 200 per request.

What it means for you

Check your bill before you check your code.Cache hits are cheaper, but a cache write now has a price where the beta charged nothing. The rates are the standard gpt-6-luna caching rates ; our item onGPT-6 Sol and GPT-6 Luna quotes that model's price table. Each response tells you what happened: cache reads are in usage.input_tokens_details.cached_tokens, cache writes in usage.input_tokens_details.cache_write_tokens, and both are already insideusage.input_tokens— do not add them to that total.

Shape your requests so the cache can work.Caching reuses a matching prefix of shared input , so put what repeats — a policy, a reference document, a reference image — ininput, and let the questions change from one request to the next, as the guide's own example does. Everything inquestions, question images included, sits outside the reusable prefix , and the prefix must hold at least 1,024 tokens, not counting question content. Keep it identical across requests. You do not have to change anything to start: by default Decisions places an implicit breakpoint at the end of shared input , so existing requests can benefit as they are. If you serve several customers,prompt_cache_keykeeps their cache reuse apart. For your own boundary, mark a text or image part of shared input withprompt_cache_breakpointin explicit mode — but in explicit mode a request with no marked boundary uses no caching at all , and breakpoints are not allowed inside question instructions.

Stop flattening your data. If you serialise an order record or a ticket into a string before asking about it, send it as input_json instead: the object or array goes in data, next to any text or image parts of a user message. It works only in the user role ; a key namedrole or image_urlinside it is plain data and creates no message and fetches no image ; and the answers come back in the same format as before.

Compare images the way the guide does. Put the reference in input, and give each candidate its own question whose instructions are an array of input_text and input_imageparts — one question per candidate image. Text-only instructions can stay a plain string. Question images count against the same image limits as the images ininput. That layout also suits the cache: the reference is in the prefix, the candidates are not. And if your images live at public URLs, you can send the URLs now instead of encoding them.

Ask more per request, but not in a chain.A request takes between 1 and 400 questions ; a question that depends on an earlier answer still needs its own request. Usage reporting counts requests, not questions — a request with several questions counts once. To read it, callGET /v1/organization/usage/decisionswith an admin API key that has theapi.usage.readpermission.

Pass the whole conversation if the decision needs it. Include tool calls and outputs in order, each output tied to its call by call_id. Decisions only answers; your application still runs whatever action the answer selects. For voice, the native GPT-Live route is now part of the API itself ; our item onGPT-Live calling Decisions walks through the switch.

The source

OpenAI's API changelog, the entry of 22 October 2026, and the Decisions API guide.