Gemini Decisions API vs OpenAI Decisions API: Which Decision Endpoint Should You Use?

Gemini Decisions API vs OpenAI Decisions API comes down to inputs and limits, not price. Both charge $0.10 per 1M input tokens and nothing for output. Pick Gemini when you need audio, video or PDF input, more than 400 questions per request, or a free tier. Pick OpenAI when you need a GA endpoint, prompt caching, JSON and tool-call evidence, or ZDR and HIPAA terms.

What a Decisions API does

A Decisions API is an endpoint that answers closed-set questions about your input instead of generating text. You send shared evidence plus a list of typed questions (yes/no, pick one option, rate on a scale) and get back probabilities and a confidence score per answer. Output tokens are zero, so you pay only for input.

OpenAI shipped the first one. Its Decisions API went GA on October 22, 2026 with gpt-6-luna. Google answered on November 11, 2026 with the Gemini Decisions API, powered by a new model, gemini-decision-1.

Both target routing, tool selection, policy checks and rubric grading. They split on what you can feed them and how far one request goes.

Gemini Decisions API vs OpenAI Decisions API at a glance

Every row comes from each vendor’s docs, read November 12, 2026. “Not documented” means the docs don’t say.

Request shape: same idea, different JSON

The two APIs look alike until you write the payload. Gemini keys questions by your own ID and calls its yes/no type noul:

result = client.decisions.create(
    model="gemini-decision-1",
    input="I was charged twice for my order.",
    questions={
        "department": {
            "type": "choice",
            "instructions": "Which department should handle this request?",
            "criteria": {"billing": "Payments and refunds.", "other": ""},
        },
    },
)

OpenAI takes an ordered array, uses predicate for yes/no, and lists choices as value and description objects. Our step-by-step OpenAI guide has the full request.

Three differences matter in production code:

1. Answer lookup. Gemini returns a map keyed by your question IDs. OpenAI returns an array you match by name.
2. Refusals. OpenAI can return a refusal answer for one question while the others still get answers. Gemini blocks the whole request with an HTTP 400 and a safety or prohibited_content code when input filters trip.
3. Choice ordering. Gemini sorts option keys alphabetically before scoring, so a key like none_of_the_above lands ahead of shipping. Use other as your catch-all on Gemini.

Gemini’s noul probabilities sit between 0.01 and 0.99, so a > 0.99 threshold never fires. The three-type question model will look familiar if you’ve read our OpenAI vs Jev comparison.

Inputs and limits: where Gemini pulls ahead

Gemini’s input reuses the Interactions API content blocks: text, image, audio, video and document (PDF). Mix a call recording with account metadata and ask 1,000 questions against it. Inline data goes up to 100 MB per request (50 MB for PDFs); Files API URIs and HTTPS URLs work up to 15 MB each. Image and video blocks take a resolution setting to trade detail for tokens.

OpenAI covers less media but more structure. Per the OpenAI Decisions guide, input accepts text, images and input_json parts, plus conversation history with function calls and their outputs. Files and audio aren’t supported. Each question’s instructions can carry its own image, handy for comparing many candidates against one reference.

The split:

• Audio, video or scanned PDFs as evidence: Gemini.
• Tool-call transcripts or raw JSON: OpenAI natively; Gemini wants them serialized to text.
• Per-question images: OpenAI only.

Pricing: same sticker, different bills

Both list $0.10 per 1M input tokens with no output charge, and both bill shared input once per request. The bills diverge on repeated input.

Gemini’s docs say plainly that the Decisions API doesn’t support context caching, Batch, Flex or Priority, and that “repeated input across requests counts in full.” OpenAI added prompt caching at GA. A shared input prefix of at least 1,024 tokens can hit the cache at $0.01 per 1M, with cache writes billed at Luna’s standard rates ($0.125 per 1M for 30-minute writes). Check OpenAI’s pricing page for the current cache rates.

A worked example (our arithmetic, not a vendor quote): every request checks the same 10,000-token policy document with 20 questions of 50 tokens each, one million times a month.

• Gemini: 11,000 tokens x 1M requests = 11B tokens x $0.10 per 1M = $1,100.
• OpenAI, all cache hits: 10B cached tokens x $0.01 per 1M = $100, plus 1B uncached question tokens x $0.10 per 1M = $100, so about $200 plus cache writes.

With fresh input on every request, such as a new ticket or photo, caching can’t help and both cost the same per token. OpenAI also applies a 2x multiplier above 272K input tokens and a 10% regional-processing uplift.

Gemini’s edge is a free tier. Google’s pricing page lists Gemini Decision input as “Free of charge” there, but free-tier data is used to improve Google’s products. Paid-tier data isn’t.

Speed and rate limits

Google says Gemini Decision 1 scores options in one forward pass: 50 to 100 ms median model compute, 150 to 250 ms end to end, nearly flat from 1 to 100 questions, for inputs up to 16K tokens. Those are Google’s claims until you measure them.

OpenAI publishes a ratio, not a number: “about 10x faster than the Responses API.” Our Decisions vs Responses API breakdown covers what that means.

Rate limits follow the same pattern. Google’s rate-limit page lists Gemini Decision limits per tier:

OpenAI doesn’t publish a Decisions-specific limit; check your organization’s limits page.

When to pick each

Pick the Gemini Decisions API when:

• Your evidence is audio, video or PDF, with no transcription or OCR step.
• You need more than 400 questions per request.
• You want to prototype at $0 in Google AI Studio.

Pick the OpenAI Decisions API when:

• You need a GA endpoint today. Gemini’s is v1beta, and Vertex AI support is “coming soon.”
• You reuse a large shared input and want caching to cut the bill.
• Your evidence is agent history with tool calls, or raw JSON.
• You need ZDR, HIPAA eligibility, or US and EU regional processing.
• You already run GPT-6 Luna or GPT-Live; OpenAI documents a native GPT-Live trigger for Decisions.

If none of those settle it, test both.

Let your coding agent run the A/B test with Apidog CLI

Vendor benchmarks don’t show how either model handles your tickets. A fixture-driven A/B test does, and your coding agent can build and run it with Apidog CLI.

Set up once:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick Claude Code, Codex, Cursor or OpenCode

Then give your agent one prompt:

In Apidog project <id>, create two endpoints: Gemini Decisions
(take the REST path from Google's Decisions API docs, model
gemini-decision-1) and OpenAI Decisions (POST /v1/decisions,
model gpt-6-luna). Both ask the same "department" choice question
(billing, technical, shipping, other) about {{ticket}}.
Build a test scenario that calls both for each row of fixtures.csv,
asserts HTTP 200, saves each answer, confidence and response time,
and flags rows where the two answers disagree. Run it and summarize.

The agent validates its payloads, writes the resources and runs the scenario once per fixture row:

apidog cli-schema get endpoint-create
apidog cli-schema validate endpoint-create --file gemini-decisions.json
apidog endpoint create --project <id> --file gemini-decisions.json
apidog endpoint create --project <id> --file openai-decisions.json
apidog cli-schema get test-scenario-create
apidog test-scenario create --project <id> --file decisions-ab.json
apidog run -t <scenarioId> --project <id> -e <envId> -d fixtures.csv -r cli,json

The -d flag feeds one CSV row per iteration, so 200 labeled tickets become 200 paired calls, and the JSON report lines up answers, confidence and timing. Compare them against your labels and you have accuracy and latency on your own data. Keep both API keys in the Apidog environment, not the prompt. See the apidog run command reference and Apidog CLI in Claude Code.

Apidog’s Free plan covers up to 4 users.

FAQ

Is the Gemini Decisions API cheaper than the OpenAI Decisions API? Not on list price: both charge $0.10 per 1M input tokens. OpenAI gets cheaper with a large reused input ($0.01 per 1M cached). Gemini is cheaper for prototyping thanks to its free tier.

Can the OpenAI Decisions API read audio or PDFs? No. It accepts text, images and JSON. Gemini adds audio, video and PDFs.

Is the Gemini Decisions API production ready? It ships as v1beta; Google Cloud support is “coming soon.” OpenAI’s endpoint has been GA since October 22, 2026.

How many questions can I ask per request? Gemini allows 1 to 1,000, bounded by its 262,144-token context window. OpenAI allows 1 to 400.

Can I switch between them without rewriting code? Not directly: question maps vs arrays, noul vs predicate, different choice formats. Put a thin adapter in front and test both on the same fixtures.