English
English
Cheap Gemini API: Four Things That Decide the Bill
Key takeaways
- Google's pricing page lists input and output separately, and the output line includes thinking tokens. A reasoning answer therefore bills for work you never see in the reply.
- Context caching is on by default for Gemini 2.5 and newer models, with a minimum input size. Google says the savings are passed on automatically, and cache hits show up in
usage.total_cached_tokens. - The same model is priced per service tier — standard, batch, flex and priority. Batch carries an explicit 50% cost reduction, and it is the only discount on that page that does not require a reseller.
- The free tier is real but conditional: limited model access, and Google states that free-tier content is used to improve its products while paid-tier content is not.
- On KuaiAPI the Gemini group speaks the Google protocol. A key bound to another group, or an OpenAI-only client, will fail — and the failure looks like a billing problem when it is a configuration one.
Why this is a fair question
The Flash line has become the default budget option for work that does not need a frontier model: classification, extraction, summarisation, routine coding help. Searching for a cheap way to call it is a reasonable instinct, and the market has answered — aggregators and resellers rank on the phrase with dedicated Gemini pages.
But the phrase hides a problem. Gemini is not sold at one rate. It is sold at a rate per token type, per model and per service tier, and the highest-leverage facts are on Google's own page, in public. Reading them takes five minutes; skipping them is how people end up asking why the bill is several times the estimate they made from the headline number.
Four lines, not one
| Line | What moves it | Where you can see it |
|---|---|---|
| Input | every token you send, including the whole conversation on each turn of a chat | the input token count in the usage block |
| Output | the visible answer plus thinking tokens | output tokens, compared with the answer you can read |
| Context caching | whether a repeated prefix clears the minimum and actually hits | usage.total_cached_tokens |
| Service tier | standard, batch, flex or priority | the rate column for the model you are calling |
A quote that names one figure is not wrong, exactly — it is answering a different question than the one you asked.
How to check: send the same long prompt twice, a couple of minutes apart, and compare the two usage blocks. If the second one reports cached tokens and a smaller charge, caching is doing its job. If the two look identical, either your prefix changed between calls or it is below the minimum.
Thinking tokens are billed as output
The output line on Google's pricing page is not just the text you read. It includes the tokens the model spends thinking before it answers. On a reasoning model that can be most of the bill for a short reply: a two-paragraph answer may carry page after page of invisible work.
This is the single most common reason a "cheap" Gemini estimate misses. People estimate from the answer they can see; the meter counts the reasoning they cannot.
How to check: take one real request that uses a reasoning model, read the output token count from the usage block, and compare it with the length of the reply. The gap is the thinking. Run the same prompt with a lower reasoning effort and watch the gap close.
Caching changed what "cheap" means
Google enables implicit caching by default on Gemini 2.5 and newer models. There is a floor — a prefix must be large enough before it is eligible (4,096 tokens on the Gemini 3 and 4 lines, 2,048 on 2.5) — and then repeated prefixes are cached without any configuration. Google states that the savings are passed on automatically, and the response reports the cached portion.
That changes the practical definition of cheap. Two teams can call the same model at the same rate and pay very different amounts, because one sends a large stable system block on every call and the other rebuilds it each time. The second team pays full input price forever and never sees a discount.
How to check: open the usage detail for a request that repeats a long block. If usage.total_cached_tokens is zero across calls that should be identical, the prefix is being changed or is under the floor. Put the stable material at the front, keep it byte-identical, and send the calls close together.
The tier you pick changes the rate
Google lists the same model under several service tiers. Standard is the interactive default. Batch is the one with a published 50% cost reduction — for work that can wait. Flex and priority sit at different points on the latency and capacity trade, with priority at the expensive end.
Two consequences follow. First, if your workload is offline (nightly extraction, bulk re-labeling, evaluation runs), the batch tier is the cheapest legitimate discount available, and you do not need a third party to get it. Second, if it is interactive, you are on standard, and the comparison should be between providers at the same tier — not between a batch rate and someone's standard rate.
How to check: classify the workload before you compare quotes. A job that can run overnight should be priced on the batch line; a chat feature should be priced on standard. Mixing the two makes every comparison meaningless.
Free is a tier with conditions
The free tier is genuine: free input and output tokens, and access for small projects. It is also narrower than the marketing implies. It covers a limited set of models — Google notes that its newest flagship is not included — and the terms are different. On the free tier, Google states that content is used to improve its products. On the paid tier, it states the opposite, and adds context caching, the batch tier and higher rate limits.
For a hobby prompt that is a fine trade. For production traffic that carries customer data, the free tier is not the same product as the paid one, and "free" is the wrong column to compare against a paid provider.
How to check: read the two columns of Google's pricing page, not just the numbers. The data-use sentence is the part that decides whether the tier fits your workload.
The client question, where protocol decides
Google publishes an OpenAI-compatible endpoint, so you can call Gemini models from the OpenAI SDK by changing the base URL and the model id. That compatibility layer belongs to Google's endpoint. It does not mean every Gemini reseller accepts the same protocol.
On KuaiAPI, the Gemini group speaks the Google protocol: the docs give Gemini CLI a gateway base URL and warn that a key's group platform must match the client protocol. So a Gemini-group key with an OpenAI-only client will fail, and an OpenAI-group key with Gemini CLI will fail. The error usually arrives as a 4xx that reads like an account problem.
How to check: look at the group's platform on the model plaza before you buy, then confirm the provider mode inside the client. One small call plus one usage record tells you whether the chain is wired correctly.
Checklist before you pay
| # | Check | Good answer |
|---|---|---|
| 1 | Is the model list public? | Flash variants readable without signing in, and the tier you want is actually there |
| 2 | Is the output line honest about thinking? | The provider says output includes reasoning tokens rather than implying otherwise |
| 3 | Is caching visible? | A cached-token field in the usage block, not just a promise of savings |
| 4 | Is the tier named? | You know whether the quoted rate is standard or batch |
| 5 | Does the key's protocol match your client? | The group platform is stated, and the client speaks that protocol |
FAQ
Is the Gemini API free? Partly. There is a free tier with limits for some models, and Google states that free-tier content is used to improve its products. It is a reasonable place to prototype and a poor fit for production traffic that carries customer data. Compare the paid tier before you build a product on the free one.
Is Gemini cheaper than ChatGPT? It depends on the tier and on how much of your output is thinking. Compare the same service tier and the same token type; a standard interactive rate and a batch rate are not the same product. Cheap DeepSeek API works the same comparison through on another family.
Can I call Gemini with my existing OpenAI SDK? Yes, against Google's OpenAI-compatible endpoint — a base URL and a model id change. On KuaiAPI the Gemini group is served over the Google protocol instead, so check the group platform before assuming an OpenAI client will work. If your stack is OpenAI-only, an OpenAI group and a model family it serves is the shorter path.
Why is my bill higher than the answer looks? Three usual reasons: thinking tokens are billed as output, the whole conversation is re-sent on every turn, and a prefix that keeps changing never gets cached. The usage block separates all three, which is why it is the first place to look.
Next step
The model plaza lists per-model rates and each group's multiplier without a login, so the tier you are comparing is visible before you commit. The status page shows how each group is running right now, and the refund page states the written path if you stop.
For the neighbouring decisions, Cheap Kimi API runs the same bill-structure check on another low-cost family, One API Key for All Models covers the client setup when one credential has to serve several tools, and the English documentation covers endpoints and key configuration.