Gemini Decisions API: Price, Limits and Developer Checklist

Updated November 12, 2026. A news analysis built from Google’s announcement post of November 11, 2026, the Decisions API documentation and the Gemini Developer API pricing page, our own screenshots of those pages, and the Hacker News front page. We read documentation and did not call the API ourselves. Everything described as a capability, price or limit comes from Google’s pages, and every number we compute is labelled as ours. This is not purchasing or architecture advice.

The short version

On November 11, 2026, Google introduced the Gemini Decisions API, a new endpoint in the Gemini API for “closed-set” decisions: you send one input (text, images, audio, video or PDFs) plus up to 1,000 questions, and the model returns a calibrated probability for each answer instead of generating text. It runs on a new model, Gemini Decision 1 (model ID gemini-decision-1). Google’s pricing page lists it at $0.10 per 1 million input tokens with no output tokens billed, and Google’s blog says end-to-end latency is 150 to 250 milliseconds.

The use cases Google names are routing a request to the right model or tool, checking content against policy rules, grading results against a rubric and reacting to UI state in real time. In other words, it is a classifier you configure with plain-language questions instead of training your own. Below we walk through what it does, the limits Google documents, a worked cost comparison that is explicitly our own arithmetic, the free-tier data detail that many teams will miss, and a checklist for deciding whether to try it.

Timeline

• November 11, 2026: Google publishes “Gemini Decisions API: Fast, calibrated multimodal decisions” on its blog.
• November 12, 2026: the post is on the Hacker News front page with about 290 points when we looked.
• November 30, 2026: last day of the current Gemini 3.5 Flash-Lite prices on Google’s pricing page ($2.00 per 1M input tokens, $10.00 per 1M output tokens).
• December 1, 2026: the same page lists new Gemini 3.5 Flash-Lite prices of $4.00 input and $20.00 output per 1M tokens. We covered the December 1 changes in our Gemini API price increase article.

What it does, in Google’s words

The documentation opens with the problem it is solving: generative models produce text for people to read, and when your code needs a judgment to branch on, generating and parsing text adds latency and brittle parsing logic. The Decisions API evaluates typed questions against your data and returns calibrated probabilities. It generates zero text tokens, so output token usage is always 0.

There are three question types:

• Yes/no (noul): returns the probability that a statement holds, always between 0.01 and 0.99, plus a confidence value. Google notes that a threshold above 0.99 can never match.
• Choice (choice): picks from 2 to 255 options and returns the top option plus calibrated probabilities for every option, summing to 1. Option keys are sorted alphabetically before evaluation.
• Score (score): rates input against 2 to 255 ordered rubric levels (2 to 10 recommended), returning a probability-weighted score, per-level probabilities and a legend.

Each answer comes with a confidence score from 0 to 1, defined as the estimated probability that the top answer is right. Google’s advice is to use the value to pick an action and the confidence to decide whether to run it automatically or hand it to a fallback or a human. Questions run in parallel and in isolation in one forward pass, cannot see each other, and latency stays nearly flat as you add questions.

The blog post gives a worked example: a photo of a breakroom counter plus a text note, checked with a yes/no question about a spill, a choice question about the cleanup action and a score question about severity, all in one request.

The numbers Google publishes

One detail in the latency claim: Google says the 50 to 100 ms compute figure holds across multimodal inputs and contexts up to 16K tokens, and that latency remains nearly flat from 1 to 100 questions per request. The documented maximum input is far larger than that, so do not assume the latency figure applies at 256K tokens.

Where Google says it is already used

• Gemini Notebook: a real-time router that sends each query to the right model tier and thinking level, which Google says serves everyday queries with up to 40 percent lower latency.
• Stitch: a “rapid canvas” experiment that generates playable wireframes of a product flow in seconds and applies edits by voice or tap.
• CC from Google Labs: picks an emoji reaction from a palette of more than 200 options.
• Google Search: a safety layer for MCP tools that detects adversarial behavior and content.

These are company-reported internal uses. None comes with published accuracy numbers in the post, and Google also says Decision 1 “leads across the suite” on benchmarks with the lowest calibration error without listing the scores in the text we read. Treat those as claims to test on your own data.

The free-tier detail to read before you prototype

The pricing table has a row called “Used to improve our products”. For Gemini Decision 1 it says Yes on the free tier and No on the paid tier. Google’s announcement points to a no-cost tier in Google AI Studio for prototyping. Put those together and the practical rule is simple: do not send customer data, internal documents or anything confidential to the free tier, because the pricing page says free-tier data is used to improve Google’s products. Use synthetic or public samples there, and move to the paid tier before testing real data. We have not verified any data-handling terms beyond that table row, so check Google’s current terms for your account.

Our own arithmetic (labelled as ours)

Google says Decision 1 is nearly 5x cheaper than Gemini 3.5 Flash-Lite across its benchmark suite. To see what the posted prices imply for a simple case, we made up a workload: 1,000 requests, each with 2,000 input tokens, where a generative model would answer with a 20-token label and the Decisions API returns no output tokens. This is a hypothetical, not a measurement.

On that made-up workload, the posted prices differ by about 21 times before December 1 (4.20 divided by 0.20) and 42 times afterward (8.40 divided by 0.20). Scaled to one million requests, that is $200 for Decision 1 against $4,200 or $8,400 for Flash-Lite. Why do we get a bigger gap than Google’s “nearly 5x”? We cannot tell from the pages: Google’s number comes from its own benchmark suite and the Interactions API, and we do not know the token mix, the thinking tokens, the number of questions per request or the caching assumptions behind it. Our table also leaves out the instruction and criteria tokens that each question adds, the thinking tokens a Flash-Lite call may use, and any difference in how the two models count tokens. The fair reading is that the price per token is far lower, and that the real saving for your workload depends on your own token counts. Measure it.

The input price comparison alone is clean arithmetic: $2.00 divided by $0.10 is 20, and $4.00 divided by $0.10 is 40.

Limits and gaps Google documents

The Limitations section is short and worth reading in full. In our paraphrase:

• It is available on the Gemini Developer API (v1beta) with Gemini Decision 1 only, and the quickstart requires SDK version 3.2 or later.
• Question instructions accept text only; media inside questions is not supported.
• YouTube URLs and direct Cloud Storage (gs://) URIs are not supported; use a Files API URI, a public or signed HTTPS URL, or inline base64 bytes.
• Conversation history, thought and tool-call blocks are not accepted as input; serialize multi-turn context as text.
• Context caching, the Batch API, and Flex or Priority inference are not supported, so repeated input across requests counts in full.
• If input safety filters block a request, the API returns an HTTP 400 error with a code such as safety, prohibited_content, blocklist, image_safety or content_blocked, instead of answers.

What this changes, and what it does not

The interesting design choice is the contract. A chat-style model returns text that your code must parse; this endpoint returns numbers that your code can compare against thresholds. That moves a whole category of glue work, such as routing, moderation pre-checks and ranking, into cheaper, faster, more predictable calls. It also makes the failure modes more visible: an answer with 0.55 confidence is plainly uncertain, while a generated sentence with a confident tone may hide the same uncertainty.

It does not remove the need for evaluation. Google’s own best practices say to set thresholds using labeled examples from your own traffic, weigh false positives against false negatives, and plan for inputs that fit no option, because a choice question always distributes probability across the options you gave it, even when none fits. Google also warns to treat input as untrusted: user-supplied text can argue for its own classification, so test with adversarial examples and keep a human or a second check on high-stakes actions such as payouts. For anyone using this as a safety or policy gate, that warning is the most important paragraph in the documentation.

There is a pattern here beyond one vendor. Earlier this month we covered Amazon’s Strands Decider and its 98 percent cost claim, another case of replacing a general-purpose model call with a purpose-built decision step. We are not saying the two products are comparable; we have not tested either. The common idea is that many agent decisions do not need a full generation. Whether the savings hold in your system depends on measured accuracy, not on list prices.

Claimed by Google versus what we could verify

Checklist before you build on it

1. List the decisions you make with generative calls today that only need a label, a route or a score.
2. Collect a labeled test set from your own traffic and measure accuracy before trusting any threshold.
3. Calculate cost with your real token counts, including each question’s instruction and criteria tokens.
4. Use the free tier only with non-sensitive data. The pricing page says it is used to improve Google’s products.
5. Set confidence thresholds and a fallback. Route ambiguous cases to a human or a stronger model.
6. Add a catch-all option and a scope check for choice questions, as Google recommends, using keys like “other” rather than positional names.
7. Test adversarial inputs. User text can argue for its own classification.
8. Check what you lose: no context caching, no Batch API, no Flex or Priority inference, and v1beta status.
9. Plan for the December 1 price change if the alternative you compare against is Gemini 3.5 Flash-Lite.

What to watch next

• Whether Google publishes the benchmark scores and calibration numbers behind the “leads across the suite” claim.
• Independent accuracy and latency tests from developers who call the API from outside Google.
• Whether the API leaves v1beta and whether caching or batch support arrives.
• Rollout of the listed ecosystem integrations, and Google Cloud support.
• Any change to the free-tier data-use terms or the $0.10 price.

For related reading, see our Claude Fable 5.2 price and benchmark analysis for another AI price story, and our AWS Emulator explainer for a developer-tools story from the same week. Browse more in our news section and tool reviews.

Frequently asked questions

What is the Gemini Decisions API?

A Gemini API endpoint, introduced on November 11, 2026, that evaluates yes/no, multiple-choice and rubric-score questions against a multimodal input and returns calibrated probabilities with confidence scores, using the Gemini Decision 1 model.

How much does it cost?

Google’s pricing page lists $0.10 per 1 million input tokens on the paid tier, with no output tokens billed. There is a free tier for prototyping.

Is my data used for training on the free tier?

The pricing page row “Used to improve our products” says Yes for the free tier and No for the paid tier. Avoid sending sensitive data to the free tier and check Google’s current terms.

How many questions can I ask per request?

From 1 to 1,000, bounded by a 262,144-token context window shared across the input and all questions.

Which inputs does it accept?

Text, images, audio, video and PDFs. YouTube URLs and gs:// URIs are not supported, and question instructions must be text only.

Can I use caching or the Batch API?

No. The documentation says the Decisions API does not support context caching, the Batch API, or Flex or Priority inference.

Is it really nearly 5 times cheaper?

That is Google’s figure for its own benchmark suite against Gemini 3.5 Flash-Lite with the Interactions API. Our simple per-token arithmetic shows a larger gap, but the real number depends on your token counts, so measure your own workload.

Is this a review?

No. We read Google’s pages and did not call the API, so we report what the company says and flag what it does not say.

Sources and method

• Google, “Gemini Decisions API: Fast, calibrated multimodal decisions”, blog.google, November 11, 2026.
• Google AI Studio documentation, “Decisions API”, aistudio.google.com/docs/decisions-api, read November 12, 2026.
• Gemini Developer API pricing page, aistudio.google.com/docs/pricing, read November 12, 2026.
• Hacker News front page, November 12, 2026.

Method: we read the announcement and the Decisions API documentation in full, read the Gemini Decision and Gemini 3.5 Flash-Lite sections of the pricing page, captured the three screenshots above ourselves, and did the cost arithmetic by hand from the posted prices on a hypothetical workload that we describe in the article. We did not call the API or measure latency or accuracy.

Risk note

Prices, limits and data terms can change, and Flash-Lite prices on Google’s page change on December 1, 2026. Check the current pages before you build or budget. This article is information, not purchasing or architecture advice. ToolReviewHub may earn commissions from some tools reviewed elsewhere on the site; no affiliate link appears in this article, and the companies named here did not pay for or review it.