SaaS · Analysis
Gemini Decisions API: $0.10 Decisions, No Output Bill
Google's new Decisions API answers yes/no, choice and rubric questions with calibrated probabilities at $0.10 per million input tokens and no output bill. Here is what it costs against Haiku 5.5 and Flash-Lite, and where it fits.
Metarix Editorial · Nov 12, 2026 · 9 min read
- Gemini Decisions API
- Claude
- OpenRouter
- Google DeepMind
- Anthropic
- SaaS Ecosystem & Business
- Benchmarks & Deep Dives
Documentation-based research

On this page
Google launched the Gemini Decisions API on November 11, 2026. It is a new Gemini API endpoint that answers yes/no, multiple-choice and rubric questions with calibrated probabilities instead of generated text. It runs on a new model, Gemini Decision 1, costs $0.10 per million input tokens and bills zero output tokens.
For anyone running routers, policy checks or LLM graders, this changes the math. Below: what the API does, what it costs against Gemini 3.5 Flash-Lite and Claude Haiku 5.5, where it falls short, and when to use it.
Quick verdict
Use the Decisions API wherever your code asks a model a closed question and then parses the answer: model routing, tool selection, ticket triage, content policy checks and rubric scoring. You get probabilities you can threshold, Google cites 150 to 250 ms latency, and one request can carry many checks for the price of reading the input once. Keep a generative model for anything that needs an explanation, extracted fields or multi-step reasoning. Don't expect big savings over Claude Haiku 5.5 on single questions: the gap is widest against Flash-class models and on many-question requests.
Scroll the table horizontally on smaller screens.
| Item | Detail |
|---|---|
| Launched | Nov 11, 2026, Gemini Developer API (v1beta) and Google AI Studio |
| Model ID | gemini-decision-1 |
| Endpoint | POST /v1beta/decisions; client.decisions.create in google-genai SDK 3.2+ |
| Question types | Yes/no (noul), choice (2–255 options), score (2–255 rubric levels) |
| Questions per request | 1 to 1,000, all against one shared input |
| Context window | 262,144 tokens across input and all questions |
| Input types | Text, images, audio, video, PDF |
| Paid price | $0.10 per 1M input tokens; output not billed (always 0 tokens) |
| Free tier | Yes: 200 RPM, 50,000 TPM, 10,000 requests per day |
| Not supported | Context caching, Batch API, Flex and Priority inference |
What Google shipped
The launch post by Google DeepMind's Min Choi and Felix Yu describes the Decisions API as an endpoint for "fast, closed-set decisions." The Gemini API release notes list it on November 11, one day after Gemini 4 Carbon went GA. The idea is simple. Generative models write text one token at a time, and your code then has to parse that text into a decision. Gemini Decision 1 skips the writing. It scores every candidate answer in a single forward pass and returns numbers.
Three question types
Scroll the table horizontally on smaller screens.
| Type | Use it for | Returns |
|---|---|---|
| noul (yes/no) | Does a condition hold? Is this a defect? Is the image damaged? | Probability of yes, clamped to 0.01–0.99, plus confidence |
| choice | Pick one queue, model tier, tool or department from a fixed list | Top option, probabilities for all options (sum to 1), confidence |
| score | Rate against an ordered rubric, such as severity or answer quality | Probability-weighted score, per-level probabilities, legend, confidence |
Every answer carries a confidence value, defined as the probability that the top answer is right. Google's guide tells you to set thresholds from labeled examples of your own traffic, weighing false positives against false negatives. The pattern is to act automatically above a threshold and fall back below it.

Where it is available
- Gemini Developer API only, for now. The model page and guide say v1beta only. Google says support for Gemini in Google Cloud is "coming soon."
- SDKs: Python and JavaScript in google-genai 3.2 or later, plus REST.
- Third parties: Google says integrations are rolling out across OpenRouter, LangChain, Vercel, LiteLLM, Pydantic AI, Pipecat, LiveKit and OpenCode. Check each one's changelog before relying on it.
Pricing: why zero output tokens matters
The pricing page lists one paid rate: $0.10 per million input tokens across text, image, video, audio and PDF. Output is "not applicable (0 output tokens)." Two billing rules make that rate go further than it looks:
- Shared input is billed once. Ask one question or 500 about the same document, and the document is counted once. Each question only adds its own instruction and criteria tokens.
- No thinking or output bill. There are no thinking tokens and no output tokens, so the cost of a request is fixed by its input. With a generative model, a verbose answer or a long reasoning trace can multiply the bill.
There are also catches. There is no context caching, so a long system context repeated on every call is billed in full each time. There is no Batch API or Flex tier either, so you can't halve the price for offline jobs, as you can with most Gemini and Claude models.
Cost per million requests, compared
Per-token prices only make sense next to the alternatives people use today: a small generative model returning JSON. We worked through two typical workloads at list prices from Google's pricing page and Anthropic's pricing page. Prices as of Nov 12, 2026. This is arithmetic, not a test. Different tokenizers count the same text differently, and real prompts carry system and tool overhead.

Scroll the table horizontally on smaller screens.
| Workload | Gemini Decision 1 | Claude Haiku 5.5 | Gemini 3.5 Flash-Lite |
|---|---|---|---|
| Per-token price (input / output per 1M) | $0.10 / $0 | $0.10 / $0.50 | $0.30 / $2.50 |
| A: router, 1,500-token input, 3 questions (~60 output tokens for generative models) | $168 | $198 | $654 |
| B: policy check, 2,000-token input, 20 rules (~300 output tokens for generative models) | $320 | $470 | $1,710 |
| Batch discount available | No | Yes, 50% | Yes, 50% |
| Context caching | No | Yes | Yes |
Two things stand out. Against Gemini 3.5 Flash-Lite, the Decisions API is roughly four to five times cheaper in both scenarios, in line with Google's own "nearly 5x" claim. Against Claude Haiku 5.5, which has the same $0.10 input price, the gap is small: 15% in the router case and about a third in the policy case. Haiku's batch discount would flip it for offline work that can wait. If cost is the only reason to switch, run your own numbers first.
The bigger savings come from avoiding thinking tokens. A reasoning model that writes a few hundred thinking tokens before a one-word label costs far more than either column above. Our cost per successful task guide explains why routing small decisions away from expensive models matters.
What Google claims on quality and speed
These are Google's numbers from the launch post. We haven't verified them, and Google didn't publish per-benchmark scores or name the comparison models in the post.
Scroll the table horizontally on smaller screens.
| Claim | Google's figure |
|---|---|
| Latency | Median 50–100 ms model compute, 150–250 ms end to end, for inputs up to 16K tokens |
| Scaling | Latency "nearly flat" from 1 to 100 questions per request |
| Quality | "Leads across the suite" on agent routing, reasoning, ranking and multimodal benchmarks, with the lowest calibration error |
| Cost | Nearly 5x cheaper across Google's benchmark suite than Gemini 3.5 Flash-Lite via the Interactions API |
| In production | Gemini Notebook uses it as a model router; Google cites up to 40% lower latency on everyday queries |
The calibration claim matters most. A raw LLM probability is often overconfident, which makes thresholds unreliable. If Decision 1's probabilities are well calibrated on your data, a 0.9 really means about nine in ten correct, and you can set an auto-approve line with known error rates. Test that on your own labeled set before trusting it.
Limits and gotchas
Scroll the table horizontally on smaller screens.
| Limit | Value |
|---|---|
| Questions per request | 1 to 1,000 (bounded by the context window) |
| Options per choice / levels per score | 2 to 255 (2 to 10 recommended for rubrics) |
| Question keys | 1–64 characters, [A-Za-z0-9_-] |
| Inline media | Up to 100 MB per request (50 MB for PDFs); external URLs up to 15 MB |
| Free tier | 200 RPM, 50,000 TPM, 10,000 RPD |
| Tier 1 / Tier 2 / Tier 3 | 1,500 / 5,000 / 15,000 RPM; 1M / 4M / 10M TPM |
- Choice keys are sorted alphabetically. The API reorders options by key, and ties go to the first key. Google advises against keys like none_of_the_above. Use "other" with a clear description instead.
- Choice always picks something. Probabilities across options always add up to 1, even when nothing fits. Pair choice questions with a yes/no scope check, or threshold confidence.
- Yes/no tops out at 0.99. A threshold above 0.99 never fires.
- Score averages level indices. A score of 1.12 can hide a split between levels. Read the per-level probabilities and keep scales linear.
- Questions can't see each other. For a dependent decision, send a second request or ask both and ignore one answer.
- Input is untrusted. Google warns that user text can argue for its own classification. Keep a human or second check on payouts and other high-stakes actions.
- No conversation history blocks. Multi-turn context has to be serialized as text, and tool-call and thought blocks are rejected.
What it looks like in code
An illustrative router that picks a model tier and checks scope in one call, based on Google's documented request shape. It was not run for this article.
# Illustrative only: route a request with one Decisions API callfrom google import genaiclient = genai.Client(http_options={"api_version": "v1beta"})result = client.decisions.create( model="gemini-decision-1", input=user_message, questions={ "in_scope": {"type": "noul", "instructions": "Is this a question about our product or account?"}, "tier": {"type": "choice", "instructions": "How much reasoning does answering this need?", "criteria": {"fast": "Lookup or short factual answer.", "standard": "Some multi-step explanation.", "deep": "Debugging, planning or analysis across sources."}}, },)a = result.answersif a["in_scope"].noul < 0.5: model = "refuse_or_redirect"elif a["tier"].confidence >= 0.7: model = {"fast": "flash-lite", "standard": "flash", "deep": "carbon"}[a["tier"].choice]else: model = "flash" # unsure: take the middle tier
The same pattern works as a cheap first-pass grader. Our LLM-as-a-judge guide covers rubric design. The Decisions API's score type fits narrow, well-defined rubric checks, while open-ended critiques still need a generative judge that explains itself.
Who should switch, and who shouldn't
Scroll the table horizontally on smaller screens.
| Workload | Recommendation | Why |
|---|---|---|
| Model or tier routing in front of every request | Use it | Low latency, fixed cost, confidence for fallbacks |
| Many policy rules over the same input | Use it | Input billed once for up to 1,000 rules |
| Tool selection and stop/escalate checks in agents | Use it | Closed choices with thresholds |
| Image, audio or video triage | Use it | Native multimodal input, no separate OCR or transcription bill |
| Overnight bulk labeling | Compare first | No batch discount; Haiku 5.5 or Flash-Lite on Batch may be cheaper |
| Extraction into JSON fields | Don't | Use structured output from a generative model |
| Answers that need an explanation | Don't | It returns numbers, not reasons |
| Google Cloud-only shops | Wait | Not yet on Gemini in Google Cloud |
If you run traffic through a gateway, check that it passes the new endpoint before you build on it. Our AI gateways comparison covers the main options, and OpenRouter is on Google's list of integrations rolling out.
Verdict
The Decisions API is the most useful kind of launch: a narrow tool for a job most AI apps already do badly. Teams route, triage and grade with general-purpose models and then parse text, paying for output tokens they don't need. Gemini Decision 1 returns probabilities instead, in a fraction of a second, with the input billed once however many questions you ask.
Our advice: move routing, scope checks and multi-rule policy checks to the Gemini Decisions API first, since they gain most from flat latency and one-time input billing. Validate calibration against a few hundred labeled examples before setting auto-approve thresholds. Keep Claude Haiku 5.5 or Flash-Lite on Batch for bulk offline labeling until you've compared the bills. And keep a generative model for any decision someone will ask you to explain. For more of Google DeepMind's recent pricing moves, see our Gemini 4 Carbon pricing analysis.
Sources
- Google: Gemini Decisions API: Fast, calibrated multimodal decisions (Nov 11, 2026)
- Google AI Studio: Decisions API guide (accessed Nov 12, 2026)
- Google AI Studio: Gemini Decision model page (accessed Nov 12, 2026)
- Google AI Studio: Gemini Developer API pricing (accessed Nov 12, 2026)
- Google AI Studio: Rate limits (accessed Nov 12, 2026)
- Google AI Studio: Gemini API release notes (Nov 11, 2026 entry)
- Google AI Studio on X: Decisions API launch post (Nov 11, 2026)
- Anthropic: Claude API pricing documentation (accessed Nov 12, 2026)
Tools covered in this article
Frequently asked questions
- How much does the Gemini Decisions API cost?
- Gemini Decision 1 costs $0.10 per million input tokens on the paid tier, and output is not billed because the model always returns zero output tokens. The shared input is billed once per request no matter how many questions you ask. There is also a free tier for prototyping in Google AI Studio.
- What is the difference between the Decisions API and structured output?
- The Decisions API returns calibrated probabilities for yes/no, multiple-choice and rubric questions without generating text. Structured output asks a generative model to write JSON that follows your schema. Use the Decisions API to route, check or score, and structured output to extract values or write explanations.
- How many questions can one Decisions API request include?
- Between 1 and 1,000 questions, all evaluated independently against one shared input. The total of the input and all question text must fit in the 262,144-token context window. Questions cannot see each other's answers.
- Is the Gemini Decisions API available on Google Cloud?
- Not yet. At launch on November 11, 2026, it is available on the Gemini Developer API (v1beta) through Google AI Studio. Google says support for Gemini in Google Cloud is coming soon.
- Does the Decisions API support batch or caching discounts?
- No. Google's documentation says the Decisions API does not support context caching, the Batch API, or Flex and Priority inference, so repeated input across requests is billed in full each time.