Gemini Decisions API Guide: Gemini Decision 1 Pricing, Answer Types and Python Example

Google just gave Gemini a second job. Instead of writing answers, the new Gemini Decisions API makes choices: yes or no, which option, what score. It launched on 11 November 2026 with a new model called Gemini Decision 1.

It reads your input once, answers up to 1,000 questions in a single pass, and charges only for input tokens. Output is free.

This guide covers how it works, the three answer types, real cost maths, working Python and REST code, every limit, how it compares with OpenAI’s Decisions API, and the errors you are likely to hit.

What the Gemini Decisions API Is

Most app logic does not need an essay. It needs a quick call: is this message spam, which model should answer this prompt, how bad is this damage photo. Developers usually force a chat model to return JSON for that, which is slow and wastes output tokens.

The Decisions API is built only for these bounded choices. Gemini Decision 1 scores every candidate answer in one forward pass instead of generating text token by token. You get probabilities and a confidence score back, not prose.

It was announced on 11 November 2026 by Google DeepMind product manager Min Choi and principal scientist Felix Yu, and promoted the same day by Sundar Pichai on X.

Note: Vertex AI is not mentioned. Google says “Gemini in Google Cloud” support is coming soon and has a sign-up form for updates.

The Three Answer Types

Every question in a request has a type, plain-English instructions and, for two of the types, criteria. Questions cannot see each other, so they run in parallel.

Yes, the yes/no type really is spelled noul in Google’s docs and SDK. It is not a typo you need to fix.

Tip: a score of 1.4 on a three-level rubric means “between level 1 and level 2”, leaning to 1. Round it or set your own cut-offs in code.

Pricing and Cost per Decision

The pricing is simple. You pay $0.10 per 1M input tokens and nothing for output, thinking, audio transcription or OCR.

The shared input is billed once per request. Each extra question only adds its own instruction and criteria tokens.

These are my own estimates from the published price, not Google figures. The lesson is clear though: batch your questions into one request, because the shared input is the expensive part.

Google also says the API was nearly 5x cheaper than Gemini 3.5 Flash-Lite through the Interactions API across its internal benchmark suite (vendor-reported). For the rest of Google’s prices, see my Gemini API pricing and free tier guide.

Warning: on the free tier, Google uses your inputs to improve its products. Use a paid key for customer data.

How to Use It in Python, Step by Step

1. Get an API key. Open Google AI Studio, go to API keys and create one. The free tier works for testing.
2. Install or upgrade the SDK. Run pip install -U google-genai. You need version 3.2 or later.
3. Set the key. Export GEMINI_API_KEY in your shell. The SDK reads it automatically.
4. Create the client with v1beta. The endpoint only exists on v1beta, so pass it in http_options.
5. Write your questions. One decision per question, full wording in instructions.
6. Act on confidence. Run the code path when confidence is high, escalate when it is not.

The minimal example (from Google’s docs)

from google import genai

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

result = client.decisions.create(
    model="gemini-decision-1",
    input="The blue mug I ordered on Monday arrived cracked on Wednesday.",
    questions={
        "is_damaged": {
            "type": "noul",
            "instructions": "Did the item arrive damaged?",
        },
    },
)

answer = result.answers["is_damaged"]
print(f"P(yes)={answer.noul:.2f} confidence={answer.confidence:.2f}")

Three questions at once, with routing

This is the pattern most apps will use: one support message, three decisions, and a confidence threshold that sends unclear cases to a person.

from google import genai

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

ticket = "Charged twice for my Pro plan this month. Please refund one payment."

result = client.decisions.create(
    model="gemini-decision-1",
    input=ticket,
    questions={
        "is_billing": {
            "type": "noul",
            "instructions": "Is this message about a payment, invoice or refund?",
        },
        "team": {
            "type": "choice",
            "instructions": "Which team should handle this message?",
            "criteria": {
                "billing": "Payments, refunds, invoices, plan changes",
                "tech": "Bugs, crashes, login or setup problems",
                "sales": "New purchases, quotes, upgrades for teams",
                "other": "Anything that fits none of the above",
            },
        },
        "urgency": {
            "type": "score",
            "instructions": "How urgent is this for the customer?",
            "criteria": ["Low: no impact", "Medium: some impact", "High: money or access at risk"],
        },
    },
)

a = result.answers
if a["team"].confidence >= 0.85:
    print("Route to", a["team"].choice)
else:
    print("Send to a human, probabilities:", a["team"].probabilities)
print("Urgency score:", round(a["urgency"].score, 2))
print("Tokens billed:", result.usage.total_input_tokens)

The question keys (is_billing, team, urgency) are just labels for matching answers. The model never sees them, so put the full question in instructions.

Images, audio, video and PDFs

The input field accepts a string, one content block or a list of blocks. Block types are text, image, audio, video and document (PDF), using the same Content format as Google’s Interactions API.

• Inline data: up to 100 MB per request (50 MB for PDFs).
• URLs: up to 15 MB per file, must be public or signed. YouTube links and gs:// URIs are not supported.
• Image detail: set resolution to low, medium, high or ultra_high. Lower resolution means fewer tokens and a lower bill.
• Text blocks: adjacent text blocks are joined with no separator, so add your own line breaks.

Google’s own blog example sends a breakroom photo and asks three things at once: is there a spill, which cleanup action fits, and how severe it is. The AI Studio playground is the quickest way to copy the exact block format for your media type.

REST and JavaScript Versions

No SDK? The REST call is a single POST to https://generativelanguage.googleapis.com/v1beta/decisions with the same body.

curl -s https://generativelanguage.googleapis.com/v1beta/decisions \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-decision-1",
    "input": "Order arrived cracked.",
    "questions": {
      "is_damaged": {"type": "noul", "instructions": "Did the item arrive damaged?"}
    }
  }'

In Node.js, install @google/genai@latest and create the client with new GoogleGenAI({ apiVersion: 'v1beta' }). Then call ai.decisions.create({ model, input, questions }) and read result.answers.is_damaged.noul.

A typical response looks like this:

{
  "answers": {
    "is_damaged": {"type": "noul", "noul": 0.99, "confidence": 0.99}
  },
  "usage": {
    "total_input_tokens": 100,
    "input_tokens_by_modality": [{"modality": "text", "tokens": 100}],
    "total_output_tokens": 0,
    "total_tokens": 100
  }
}

New to the SDK in general? My Gemini API Python tutorial covers keys, models and basic calls first.

Limits, Rate Limits and Supported Inputs

Rate limits are from Google’s rate-limit table as summarised by developer Flavio Copes; check your own project’s quota page, since limits change by tier. My LLM API rate limits guide explains how tiers work across providers.

What Google Already Uses It For

Google listed four internal users at launch. These are Google’s own claims, not independent results.

Other natural fits: moderation, lead scoring, routing prompts between cheap and expensive models, checking agent tool calls before they run, and grading RAG context for relevance.

Gemini vs OpenAI Decisions API vs Structured Outputs

OpenAI shipped its own Decisions API on GPT-6 Luna in October, and I covered it in my OpenAI Decisions API guide. Here is how the two compare, plus the old JSON approach.

• Pick Gemini when inputs include audio, video or PDFs, when you ask many questions per item, or when you want a free tier to prototype.
• Pick OpenAI when a long fixed prompt repeats on every call (caching cuts it to $0.01) or you need inputs above 262K tokens.
• Use Structured Outputs when you need to extract open values like names, dates or totals. My structured outputs guide covers that across Claude, OpenAI and Gemini.

Accuracy Tips From Google’s Docs

• One thing per question. Split “is it urgent and about billing?” into two questions.
• Phrase positively. Ask “Is the item intact?” and compute the negative as 1 - noul in code.
• Do maths in code. Compare dates and numbers yourself, then pass the result as input.
• Send only what matters. Unrelated fields in the input lower accuracy.
• Add a catch-all. choice always spreads probability across your options, even for junk input. An other option or a confidence check stops forced wrong answers.
• Use non-positional keys. Option keys are sorted alphabetically, so name them by meaning, not “a, b, c”.
• Keep score levels linear. The score is an index average, so uneven gaps distort it.
• Calibrate thresholds. Label a few hundred real inputs by hand, then pick the confidence where errors become acceptable.

Warning: treat input as untrusted. Text inside a ticket or PDF can try to steer the answer, so keep a human or a second check in front of anything that moves money or deletes data.

Troubleshooting Common Errors

For general Gemini API errors like invalid keys or region blocks, see my Gemini API errors fix guide.

My Take

This is one of the most useful launches of the month for anyone building agents. Routing, guardrails and tool selection are the hidden glue of every AI app, and they have been running on chat models that were never built for them.

The two numbers that matter are free output and 1,000 questions per pass. That makes it realistic to check every agent step against a list of policies without doubling your bill or your latency.

The gaps are real. There are no published per-benchmark scores yet, no caching, and no Vertex AI support, so enterprise teams on Google Cloud have to wait. I would prototype on the free tier now, measure accuracy on your own labelled data, and keep a fallback to a reasoning model for low-confidence cases.

If you already use OpenAI’s version, the choice mostly comes down to media types and caching. For multimodal inputs, Google has the edge today. For function-calling agents that need the next step, pair this with my Gemini function calling tutorial.

FAQ

Is the Gemini Decisions API free?

There is a no-cost tier in Google AI Studio for prototyping, limited to 200 requests per minute and 10,000 per day. Paid use costs $0.10 per 1M input tokens with no output charge.

What is Gemini Decision 1?

It is the model behind the Decisions API, with the ID gemini-decision-1. It scores candidate answers in one forward pass instead of generating text, so it returns probabilities rather than sentences.

Why is the yes/no type called “noul”?

That is simply the name Google uses in its API and SDK for yes/no questions. Use "type": "noul" exactly as written, and read the probability from the noul field.

Can it read images, audio and PDFs?

Yes. The shared input can mix text, images, audio, video and PDFs, up to 262,144 tokens. Inline data can be up to 100 MB per request, or 50 MB for PDFs.

Is it available on Vertex AI?

Not at launch. It runs on the Gemini Developer API and Google AI Studio, and Google says Google Cloud support is coming soon.

Can questions depend on each other?

No. All questions in a request are independent and cannot see each other’s answers. If one answer decides the next question, send a second request.

How fast is it?

Google reports a median of 50-100 ms of model compute and 150-250 ms end to end, staying nearly flat from 1 to 100 questions. These are vendor numbers, so test with your own inputs and region.

Should I replace Structured Outputs with it?

Only for closed choices like yes/no, categories and scores. Keep Structured Outputs for extracting open values such as names, prices or dates.

Sources

• Google blog: “Gemini Decisions API” by Min Choi and Felix Yu, 11 November 2026 (blog.google)
• Google AI Studio docs: Decisions API quickstart, limits and error codes (aistudio.google.com/docs/decisions-api)
• Sundar Pichai and @Google launch posts on X, 11 November 2026
• Philipp Schmid, “Fast multimodal control flow with the Gemini Decisions API”, DEV Community
• Flavio Copes, “How to use the Gemini Decisions API” (request/response format, rate-limit summary)
• OpenRouter model page: google/gemini-decision-1