How to Use the Gemini Decisions API for Free

You can use the Gemini Decisions API for free today. Google’s free tier for gemini-decision-1 charges nothing for input, bills no output tokens, and allows 200 requests per minute, 50,000 tokens per minute and 10,000 requests per day per project. You need an AI Studio API key and no billing account. The catch: on the free tier, Google may use your content to improve its products.

Below: what those limits mean in real workloads, the token math behind the $0.10 per 1M paid price, the other $0 routes, and how to keep tests and CI off your daily quota. Every quota and price was read from Google’s official pages on November 12, 2026. The API ships as v1beta, so recheck before you budget. For the question types themselves (noul, choice, score), see Google’s Decisions API guide.

What the Gemini Decisions API free tier includes

The Gemini Decisions API free tier is the no-cost usage tier of Google’s Gemini Developer API applied to the gemini-decision-1 model. It gives each Google Cloud project free input processing, zero output charges, and fixed rate limits of 200 RPM, 50,000 TPM and 10,000 RPD, with no billing setup required.

Here’s what Google’s pricing page and rate limits page say, side by side:

Three details matter more than the headline numbers:

• Limits are per project, not per API key. Creating five keys in one project doesn’t give you five quotas.
• The daily cap resets at midnight Pacific time. A batch job that starts at 11 p.m. Pacific gets one hour of one day’s quota and a fresh 10,000 after midnight.
• Free-tier data can be used by Google. The pricing table marks “Used to improve our products” as Yes on the free tier and No on paid. Don’t send customer PII, contracts or medical images through a free key.

How to get a free Gemini Decisions API key

You can be making free calls in about five minutes:

1. Sign in to Google AI Studio and click Create API key. A new project starts on the free tier.
2. Install SDK 3.2 or later: pip install -U google-genai or npm install @google/genai@latest.
3. Export the key as GEMINI_API_KEY so the SDK picks it up.
4. Send one request with http_options={"api_version": "v1beta"} and read the usage block in the response.

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.",
    questions={
        "is_damaged": {"type": "noul", "instructions": "Did the item arrive damaged?"},
    },
)

print(result.answers["is_damaged"].noul)
print(result.usage.total_input_tokens)

That usage.total_input_tokens number is the one to log. On the free tier it’s what burns your 50,000 TPM; on paid it’s the only thing you’re billed for.

For the rest of Google’s free offers, see our Gemini API free tier guide and how to use Gemini for free.

How Gemini Decisions API pricing works

You pay only for input tokens, and the shared input is counted once per request no matter how many questions you ask. Each question adds just its own instruction and criteria tokens. Output is always 0 tokens, because the model returns probabilities, not text.

So the formula for one request is simple:

input tokens = shared input + sum(each question's instructions + criteria)
paid cost    = input tokens / 1,000,000 x $0.10

The interesting part is what that does to the free tier. With text, the request count (200 RPM, 10,000 RPD) usually binds first. With images, audio or long documents, the 50,000 TPM limit binds first.

Worked cost examples: free tier vs paid

The question-token figures below are estimates (about 30 tokens per short question). Image and audio counts come from Google’s media resolution table, which lists 280 tokens per image at low, 1,120 at high, and 25 tokens per second of audio for current Gemini models. Run one real request and replace my numbers with your own usage values.

10,000 product photos x 16 questions

Say you check delivery photos for damage, placement, label legibility and 13 other things.

• Per request at low resolution: 280 (image) + 20 (text context) + 16 x 30 (questions) = 780 tokens
• 10,000 photos: 10,000 x 780 = 7.8M tokens
• Paid cost: 7.8 x $0.10 = $0.78
• At high resolution: 1,120 + 20 + 480 = 1,620 tokens per photo, 16.2M tokens, $1.62

On the free tier, TPM decides your speed: 50,000 / 780 = about 64 photos a minute. All 10,000 finish in roughly 2 hours 36 minutes and use exactly one day’s 10,000 requests. At high, it’s about 30 a minute and 5.5 hours.

Now the mistake to avoid. If you send the 16 checks as 16 separate requests, each one re-sends the image: 16 x 300 = 4,800 image-and-context tokens plus the same 480 question tokens, about 5,280 per photo. That’s 52.8M tokens ($5.28 paid) and 160,000 requests, which is 16 days of free-tier quota. Batch the questions.

10,000 support tickets x 3 routing questions

• Per request: 250 (ticket text) + 3 x 40 (questions with criteria) = 370 tokens
• 10,000 tickets: 3.7M tokens, $0.37 paid
• Free tier: 50,000 / 370 = 135 requests a minute, under the 200 RPM cap. One day’s 10,000 requests covers 10,000 tickets.

Long PDFs

The context window is 262,144 tokens, but the free TPM is 50,000, so one 120,000-token contract exceeds a full minute of free budget. Google’s docs don’t say how the free tier handles a single request above the TPM cap, so test one first. Long documents are where Tier 1 (1M TPM) pays for itself.

Other ways to use Gemini Decision 1 at $0

OpenRouter’s model page, checked November 12, 2026, lists one provider (Google AI Studio) at $0.10 per 1M input, free output, and no :free variant. It runs on OpenRouter’s Decisions endpoint, so chat completions SDKs won’t call it.

How to stay inside the free tier

These habits keep a prototype at $0 for as long as possible:

1. Ask every question in one request. Shared input is billed once, and up to 1,000 questions fit in one call.
2. Drop media resolution. low costs a quarter of high per image.
3. Send only the fields the questions need. Google says unrelated content lowers accuracy, and it burns TPM.
4. Throttle to TPM, not RPM. Pace workers to 50,000 divided by your measured tokens per request.
5. Cache answers yourself. The API has no context caching and counts repeated input in full, so hash input plus questions and skip repeats.
6. Start big runs after midnight Pacific to get a full day of quota.
7. Keep tests and CI off the real API. A suite that calls it on every push can spend 10,000 requests by lunch. Mock it instead.

Let your coding agent mock the Decisions API with Apidog CLI

Unit tests don’t need a live model. They need the right shape: an answers map, noul between 0.01 and 0.99, a confidence, and usage.total_output_tokens: 0. Your coding agent can build that mock with Apidog CLI, so only one smoke test touches Google.

Set up once:

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install

Then give Claude Code, Codex or Cursor one prompt:

In Apidog project <id>, add the Gemini Decisions endpoint POST /v1beta/decisions
with a request body of model, input and questions. Create mock expectations that
return a damaged answer (noul 0.97) and an undamaged one (noul 0.04), each with
usage.total_output_tokens = 0. Add a test case that asserts the answers map,
confidence between 0 and 1 and zero output tokens. Run it against the mock
environment, then once against the real API with my free-tier key.

The agent reads each payload schema, validates it, and only then writes:

apidog cli-schema get endpoint-create
apidog cli-schema validate endpoint-create --file decisions-endpoint.json
apidog endpoint create --project <id> --file decisions-endpoint.json

apidog cli-schema get mock-create
apidog cli-schema validate mock-create --file mock-damaged.json
apidog mock create --project <id> --file mock-damaged.json

apidog cli-schema get test-case-create
apidog test-case create --project <id> --file decisions-case.json
apidog run --test-case <caseId> --project <id> -e <mockEnvId> -r cli,json
apidog run --test-case <caseId> --project <id> -e <freeTierEnvId> -r cli

In CI, run only the mock environment with -r junit (pipeline file in our Apidog CLI CI/CD guide); agent setup is in Apidog CLI in Claude Code. Apidog’s Free plan covers up to 4 users, so a small team shares the mocks at no cost. Weighing OpenAI’s version too? See our OpenAI Decisions API explainer.

FAQ

Is the Gemini Decisions API free? Yes, within limits. The free tier charges nothing for input and output is always 0 tokens. You get 200 requests per minute, 50,000 tokens per minute and 10,000 requests per day per project. Past that, set up billing and pay $0.10 per 1M input tokens.

Do I need a credit card for the Gemini Decisions API free tier? No. An API key from Google AI Studio starts on the free tier. Google’s rate limits page says you move to a paid tier only after you set up billing in AI Studio.

Does Google train on my free-tier Decisions API data? Google’s pricing page marks “Used to improve our products” as Yes for the free tier and No for paid. Treat free-tier keys as unsuitable for sensitive data.

Why am I hitting 429 errors well under 200 requests per minute? You’re probably over 50,000 tokens per minute. Image, audio and PDF inputs are token-heavy, so TPM usually binds before RPM. Log usage.total_input_tokens and pace requests to 50,000 divided by that number.

Is there a free Gemini Decision 1 model on OpenRouter? Not as of November 12, 2026. OpenRouter lists google/gemini-decision-1 at $0.10 per 1M input tokens and $0 output, with no :free variant.

Can I use Batch API or context caching to stretch the free tier? No. The model page lists Batch API and caching as not supported on any tier. Batch questions into one request and cache answers in your own code.