Gemini Decision API: gemini-decision-1 Price, the Three Question Types and How to Call It

Short answer

Google released Gemini Decision on November 11, 2026, under the model ID gemini-decision-1. It is not a chat model. You send one body of material — text, image, audio, video or PDF — together with a batch of questions, and it returns a calibrated probability for each question in a single pass.

The pricing is unusually simple: $0.10 per million input tokens, and output is not billed at all, because it produces zero output tokens.

gemini-decision-1 is not callable on Moyi API yet. Not because we are waiting on the upstream, but because it uses a different interface: it runs on a dedicated POST /v1beta/decisions endpoint rather than the generateContent path that every other model goes through. So it does not behave like Gemini 4 Carbon, where the same key plus a new model name is enough. We have to support that endpoint before a Moyi API key can reach it. To use it today, you need to call Google's API directly with a Google API key.

How it differs from a normal chat model

A chat model takes material and writes a response. Gemini Decision takes material and answers a set of questions you wrote in advance, and the answer is a probability rather than a paragraph.

The practical consequences:

• Zero output tokens. Nothing is generated, so there is no output charge and latency stays low.
• Many questions in one request. Up to 1,000, all sharing the same input. Shared input is billed once, so asking 200 questions costs almost the same in input tokens as asking one.
• Answers come with confidence. Each question returns a probability plus a confidence score, so you pick your own threshold.
• Questions are independent. Each one is evaluated against the shared input on its own; adding or removing one does not change the others.

The three question types and their limits

Other boundaries, all from Google's documentation:

• 1 to 1,000 questions per request; shared input plus all questions must fit in 262,144 tokens.
• Question keys are 1 to 64 ASCII characters matching [A-Za-z0-9_-].
• Question instructions are text only. The input can be text, image, audio, video or a PDF, with video frames and PDF page images counted as image tokens.
• Multi-turn context has to be serialized into text yourself; tool-call blocks cannot be used as input.
• Not supported: the Batch API, context caching, Flex or Priority inference. Repeated input across requests is billed in full every time.

Pricing

Google's list price per 1 million tokens, in USD:

Per Google's rate limits, the free tier allows 200 RPM / 50,000 TPM / 10,000 requests per day; Tier 1 allows 1,500 RPM / 1,000,000 TPM / 50,000 requests per day.

The Moyi API price will be published on the pricing page once we support the endpoint.

How to call it (Google direct, for now)

The REST call goes to /v1beta/decisions — note that this is not generateContent:

curl -X POST "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": "The blue mug I ordered on Monday arrived cracked on Wednesday.",
    "questions": {
      "is_damaged": {
        "type": "noul",
        "instructions": "Did the item arrive damaged?"
      },
      "queue": {
        "type": "choice",
        "instructions": "Which support queue should handle this message?",
        "criteria": {
          "billing": "Payment, invoice, or refund questions.",
          "replacements": "Damaged, missing, or wrong items.",
          "general": "Product questions and account issues."
        }
      }
    }
  }'

The Python SDK needs v1beta set explicitly, otherwise the decisions namespace is not available:

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?",
        },
        "queue": {
            "type": "choice",
            "instructions": "Which support queue should handle this message?",
            "criteria": {
                "billing": "Payment, invoice, or refund questions.",
                "replacements": "Damaged, missing, or wrong items.",
                "general": "Product questions and account issues.",
            },
        },
    },
)

for key, answer in result.answers.items():
    print(key, answer)

The response returns answers under the same keys you used in questions, and a usage block that contains input tokens only — output is always zero. When an input safety filter blocks the request you get HTTP 400 with an error.code of safety, prohibited_content, blocklist, image_safety or content_blocked, instead of answers.

What it is good for

Google's own examples are all cases where one body of material has to clear many separate judgments:

• Request routing: one user message, several checks at once — is this a refund issue, does it need a human, which queue owns it.
• Policy checks: a contract or a screenshot run against dozens of rules in one request.
• Rubric scoring: rate candidate answers against a rubric and rank by the weighted expected score.
• Tool selection: pick the most suitable tool out of a set.
• Low-latency classification of live media: classify video or audio as it streams in.

The inverse matters too: tasks that need it to write something or reason across steps are the wrong fit. It does not generate text, it returns probabilities.

When it will work on Moyi API

gemini-decision-1 is not in our model catalog right now, so a Moyi API key will fail on it. We need to support the /v1beta/decisions path first, and once that is in place the model will show up on the pricing page — you top up a balance (from $5) and pay per token, with no Google account needed.

Until then, if you need "many judgments over one input", you can get there with Gemini 4 Argon or Gemini 4 Carbon using structured output. The trade-off is that every call generates output tokens, so the cost is well above $0.10. See Gemini 4 Argon API and Gemini 4 Carbon API.

FAQ

Is Gemini Decision out? Yes. It became generally available in the Gemini API on November 11, 2026, with the model ID gemini-decision-1.

How much does Gemini Decision cost? $0.10 per million input tokens; output is not billed because it produces no output tokens. The free tier is free.

Can I use it as a chat model? No. It only runs on /v1beta/decisions, takes "material plus a batch of questions", and returns a probability per question instead of generating text.

Can I call gemini-decision-1 on Moyi API? Not yet. We do not support the /v1beta/decisions endpoint. Once we do, it will appear on the pricing page.

Once it is live, is changing the model name enough? No. Its interface is different from ordinary models, so it will not work by swapping the model name the way Gemini 4 Carbon does. We will document the usage once we support it.

Does it support the Batch API? No. Context caching, Flex and Priority inference are also unsupported.

Related

• Gemini 4 Carbon API: a regular chat model that writes a response
• Gemini 4 Argon API: model ID, pricing and request examples
• Gemini API changelog: the official announcement
• Decisions API documentation: full field and limit reference