New video: 9 Ways To Use AI With Gadgets You Already Own →
Muddaser

Gemini Decisions API: Python Quickstart, Pricing & Limits

Direct answer: Google’s new Gemini Decisions API is for fast, closed-ended judgments—not text generation. With the gemini-decision-1 model, one request can evaluate up to 1,000 yes/no, multiple-choice, or rubric-scoring questions against shared text, images, audio, video, or PDF input. It returns probabilities and confidence scores, uses zero output tokens, and costs $0.10 per 1 million input tokens on the paid tier.[1][2]

Quick start checklist

  1. Open Google AI Studio and create an API key.[1]
  2. Install or upgrade the official SDK: pip install -U google-genai.[2]
  3. Use API version v1beta and model ID gemini-decision-1.[2][3]
  4. Send one shared input plus one or more typed questions.[2]
  5. Put a confidence threshold and a human-review fallback in your application code.[2]

The official quickstart requires google-genai SDK 3.2 or later. The endpoint is currently available through the Gemini Developer API v1beta, not as a normal text-generation call.[2][3]

Working Python example

The example below follows the documented pattern for asking independent noul, choice, and score questions about one shared input.[2]

from google import genai

client = genai.Client(http_options={"api_version": "v1beta"})

result = client.decisions.create(
    model="gemini-decision-1",
    input=(
        "Order 8821 arrived with a cracked screen. "
        "The customer needs a replacement before Friday."
    ),
    questions={
        "is_damaged": {
            "type": "noul",
            "instructions": "Did the item arrive physically damaged?",
        },
        "route": {
            "type": "choice",
            "instructions": "Which queue should handle this request?",
            "criteria": {
                "billing": "Charges, invoices, payment failures, or refunds.",
                "replacement": "An item arrived broken, missing, or incorrect.",
                "general": "Product information or account questions.",
            },
        },
        "urgency": {
            "type": "score",
            "instructions": "How urgently should a person review this case?",
            "criteria": [
                "No deadline or operational impact.",
                "A workaround exists and the deadline is flexible.",
                "A stated deadline or blocked customer needs prompt action.",
            ],
        },
    },
)

answers = result.answers

if answers["route"].confidence >= 0.75:
    queue = answers["route"].choice
else:
    queue = "human_review"

print("Damage probability:", answers["is_damaged"].noul)
print("Queue:", queue)
print("Urgency score:", answers["urgency"].score)
print("Input tokens:", result.usage.total_input_tokens)

Do not hard-code a production threshold just because 0.75 appears in this example. Test thresholds against labeled examples from your own workflow, including ambiguous, incomplete, and adversarial inputs.[2]

The three question types

1. noul: yes/no probability

noul estimates the probability that a condition is true. The returned value ranges from 0.01 to 0.99, and the response also includes confidence. Optional true and false descriptions can make an ambiguous rule more precise.[2]

Use it for questions such as:

  • Does this ticket report physical damage?
  • Does this document contain the required signature?
  • Is this request within the automation policy?
  • Should this case be escalated for human review?

The unusual name is part of the API schema. Use "type": "noul"; changing it to boolean or yes_no will not match the documented request format.[2]

2. choice: select one fixed option

choice selects from 2 to 255 options. It returns the winning option, normalized probabilities for every candidate, and confidence. Google’s documentation notes that option keys are sorted alphabetically before evaluation, and exact probability ties go to the alphabetically first key.[2]

Use it for routing to a queue, model, agent, tool, policy category, or next action. Include a clear description for each option and plan for inputs that fit none of them.[2]

3. score: grade against an ordered rubric

score evaluates 2 to 255 ordered levels, although Google recommends 2 to 10 levels for most rubrics. The returned score is a probability-weighted average of the level indexes, so it can fall between levels. Read the per-level probabilities and confidence as well as the headline score.[2]

Use it for urgency, relevance, quality, risk, severity, or candidate ranking. Define adjacent levels operationally; labels such as “low,” “medium,” and “high” are too vague without criteria.[2]

Pricing and cost examples

Google lists Gemini Decision 1 at $0.10 per 1 million input tokens and $0 for output tokens. A free tier is available for prototyping. Shared input is billed once per request, while each added question contributes its own instruction and criteria tokens.[1][4]

Illustrative paid-tier input costs at the current list price:

  • 10,000 requests averaging 2,000 input tokens: 20 million tokens, or $2.[4]
  • 100,000 requests averaging 5,000 input tokens: 500 million tokens, or $50.[4]
  • 1 million requests averaging 1,000 input tokens: 1 billion tokens, or $100.[4]

These examples exclude any other services in your application. Measure actual total_input_tokens from API responses and recheck Google’s live pricing before setting a budget.[2][4]

Limits you need to know

The current documented limits are:[2][3]

  • Questions per request: 1 to 1,000.[2][3]
  • Context window: 262,144 tokens across shared input and all questions.[2][3]
  • Choice options: 2 to 255 per question.[2][3]
  • Score levels: 2 to 255; 2 to 10 recommended for most rubrics.[2]
  • Output token limit: 0.[2][3]
  • Inline upload size: up to 100 MB per request, or 50 MB for PDFs.[2]
  • External URL size: up to 15 MB per URL.[2]
  • Supported shared inputs: text, images, audio, video, and PDF documents.[2][3]

Important current limitations include no conversation-history blocks, tool calls, thinking blocks, context caching, Batch API, Flex inference, Priority inference, YouTube URLs, or direct gs:// Cloud Storage URIs. Questions themselves are text-only. For multi-turn context, serialize the relevant history as plain text.[2][3]

Decisions API vs structured output

Use the Decisions API when the possible outcomes are already bounded and your code needs probabilities it can threshold. Examples include selecting a support queue, checking many policy rules against one document, ranking candidates against a fixed rubric, or deciding whether to escalate.[2]

Use a generative Gemini model with structured output when you need:

  • generated explanations or summaries;[2]
  • extracted names, dates, amounts, or arbitrary JSON objects;[2]
  • tool calls and arguments;[2][3]
  • multi-step reasoning;[2][3]
  • an answer that is not limited to predefined choices.[2]

Gemini Decision 1 does not generate prose. That is the point: it scores predefined outcomes rather than producing and then parsing a textual answer.[2][3]

Safe production pattern

A useful production flow is:

  1. Define an atomic question. Ask one operational question at a time.[2]
  2. Describe every outcome. Make choice options and score levels mutually understandable.[2]
  3. Set a tested threshold. Route low-confidence results to another model or a person.[2]
  4. Keep deterministic rules in code. Compare exact dates, prices, balances, permissions, and legal thresholds outside the model.[2]
  5. Log the distribution. Store the selected outcome, probabilities, confidence, model ID, and policy version where privacy rules permit.
  6. Evaluate drift. Re-run a labeled test set when criteria, model versions, or upstream data change.

Google explicitly advises treating user input as untrusted, testing adversarial examples, and retaining human or secondary checks for high-stakes actions such as payouts.[2]

Where Gemini Decision 1 fits best

Good initial uses include:

  • routing support tickets by topic and urgency;[1][2]
  • checking document completeness before human review;[2]
  • selecting a cheaper or more capable model for a request;[1][2]
  • grading retrieved passages for relevance;[1][2]
  • choosing an agent tool from a fixed list;[1][2]
  • screening media against explicit operational rules;[2][3]
  • prioritizing leads or applications against a disclosed rubric.[2]

Avoid using a confidence score as proof that a decision is correct. Calibration helps you design thresholds, but production accuracy still depends on representative evaluation data, clear criteria, and an escalation path.[2]

FAQ

Is Gemini Decisions API available now?

Yes. Google announced it on November 11, 2026, and says developers can access it through the Gemini API in Google AI Studio.[1]

What is the Gemini Decision 1 model ID?

The documented model ID is gemini-decision-1.[2][3]

Does it generate text?

No. Gemini Decision 1 returns calibrated probabilities for yes/no, choice, and score questions with zero output tokens.[2][3]

Can one request mix question types?

Yes. One request can mix noul, choice, and score questions against the same shared input.[1][2]

Can it analyze images, audio, video, and PDFs?

Yes. Those modalities are supported as shared input, along with text. Question instructions remain text-only.[2][3]

Is it a replacement for Gemini Flash or Carbon?

No. Use a generative model when you need prose, extraction, reasoning, or tool calls. Use Gemini Decision 1 for bounded outcomes and calibrated probabilities.[2][3]

Sources

  1. Gemini Decisions API: Fast, calibrated multimodal decisions
  2. Decisions API – Gemini API
  3. Gemini Decision – Gemini API
  4. Gemini Developer API pricing


Leave a Comment