If you are comparing Gemini API pricing in 2026, the hardest part is not finding a rate card. It is deciding which rate card applies to your workload.
Search results routinely mix four different products: the Gemini Developer API, Google AI Studio's testing experience, Vertex AI or other Google Cloud services, and consumer Gemini subscriptions. This guide focuses on the Gemini Developer API and uses Google's official pricing and billing pages checked on July 27, 2026.
The short answer is that Gemini API cost depends on five variables:
- the model family you select
- input and output token volume
- whether individual prompts cross a long-context threshold
- whether the workload can use Batch pricing
- add-ons such as context caching, grounding, audio, images, or video
That means the lowest headline token price is not always the lowest production cost. The useful comparison is a workload-cost table with the same assumptions applied to every candidate model.
Gemini API pricing at a glance
The table below summarizes the main text-capable Gemini Developer API rows that teams are most likely to compare. Prices are in US dollars per 1 million tokens, based on Google's official Gemini Developer API pricing page.
| Model | Status | Standard input | Standard output | Batch input | Batch output | Context cache write | Cache storage per hour |
|---|---|---|---|---|---|---|---|
| Gemini 3.6 Flash | Preview | $0.40 | $2.40 | $0.20 | $1.20 | $0.04 | $1.00 |
| Gemini 3.5 Flash | Preview | $1.50 | $9.00 | $0.75 | $4.50 | $0.15 | $1.00 |
| Gemini 3.5 Flash-Lite | Preview | $0.25 | $1.50 | $0.125 | $0.75 | $0.025 | $1.00 |
| Gemini 3.1 Flash-Lite | Preview | $0.25 | $1.50 | $0.125 | $0.75 | $0.025 | $1.00 |
| Gemini 2.5 Pro | Stable | $1.25 up to 200k; $2.50 above 200k | $10.00 up to 200k; $15.00 above 200k | $0.625 up to 200k; $1.25 above 200k | $5.00 up to 200k; $7.50 above 200k | $0.125 up to 200k; $0.25 above 200k | $4.50 |
| Gemini 2.5 Flash | Stable | $0.30 | $2.50 | $0.15 | $1.25 | $0.03 | $1.00 |
| Gemini 2.5 Flash-Lite | Stable | $0.10 | $0.40 | $0.05 | $0.20 | $0.01 | $1.00 |
For Gemini 3.6 Flash, Gemini 3.5 Flash, the Flash-Lite preview models, and the Gemini 2.5 Flash families, audio input has a higher rate than text, image, or video input. The table uses the text, image, and video input rate so that the model rows remain comparable.
Preview models can change before stable release. If your production policy requires fixed behavior, longer deprecation windows, or a stable model identifier, compare the preview economics with the stable Gemini 2.5 rows instead of selecting on price alone.
What changed in the July 27, 2026 refresh
The most important change since the previous version of this guide is the current-model lineup.
- Gemini 3.6 Flash Preview now appears as a high-throughput option at $0.40 input and $2.40 output per million tokens.
- Gemini 3.5 Flash-Lite Preview now appears at $0.25 input and $1.50 output per million tokens.
- The earlier Gemini 3.1 Flash-Lite row remains visible, but buyers should confirm which preview model identifier they intend to operate.
- The stable Gemini 2.5 models remain useful comparison anchors for teams that value lifecycle predictability.
This is why a Gemini pricing page needs scheduled maintenance. A correct table can become strategically misleading even when every old number is still technically present somewhere in the catalog.
Gemini API workload-cost table
The table below converts rates into budget estimates. These scenarios are not quality benchmarks, and the models are not interchangeable. They answer a narrower finance question: what would the token bill be if the same workload ran on each route?
Assumptions
| Workload | Request volume | Input per request | Output per request | Total input | Total output |
|---|---|---|---|---|---|
| Classification and extraction | 1,000 requests | 2,000 tokens | 300 tokens | 2M tokens | 0.3M tokens |
| Retrieval-augmented assistant | 1,000 requests | 20,000 tokens | 1,000 tokens | 20M tokens | 1M tokens |
| Long-document review | 100 requests | 150,000 tokens | 5,000 tokens | 15M tokens | 0.5M tokens |
The long-document scenario keeps each prompt below Gemini 2.5 Pro's 200k threshold. Grounding, caching, audio, image generation, and video generation are excluded.
Estimated Standard-tier token cost
| Model | Classification | RAG assistant | Long-document review |
|---|---|---|---|
| Gemini 3.5 Flash-Lite | $0.95 | $6.50 | $4.50 |
| Gemini 3.6 Flash | $1.52 | $10.40 | $7.20 |
| Gemini 2.5 Flash-Lite | $0.32 | $2.40 | $1.70 |
| Gemini 2.5 Flash | $1.35 | $8.50 | $5.75 |
| Gemini 3.5 Flash | $5.70 | $39.00 | $27.00 |
| Gemini 2.5 Pro | $5.50 | $35.00 | $23.75 |
These totals show why a workload table is more useful than a model list.
- For narrow extraction, the stable Gemini 2.5 Flash-Lite row has the lowest token cost in this comparison.
- Gemini 3.6 Flash costs more than the Lite routes but substantially less than Gemini 3.5 Flash under the same assumptions.
- In the long-document example, Gemini 2.5 Pro's token bill is lower than Gemini 3.5 Flash's because the prompt stays below the Pro threshold. That does not prove it is the better model, but it prevents a misleading assumption that every Pro workload must cost more.
- Output-heavy applications are more sensitive to model choice because output tokens cost more than text input tokens on every row shown here.
What Batch pricing does to the same workloads
For rows that support the Batch API, Google's listed Batch token rates are generally half the Standard rates. If every request in the scenarios above can run asynchronously, the estimated token totals become:
| Model | Classification with Batch | RAG assistant with Batch | Long-document review with Batch |
|---|---|---|---|
| Gemini 3.5 Flash-Lite | $0.475 | $3.25 | $2.25 |
| Gemini 3.6 Flash | $0.76 | $5.20 | $3.60 |
| Gemini 2.5 Flash-Lite | $0.16 | $1.20 | $0.85 |
| Gemini 2.5 Flash | $0.675 | $4.25 | $2.875 |
| Gemini 3.5 Flash | $2.85 | $19.50 | $13.50 |
| Gemini 2.5 Pro | $2.75 | $17.50 | $11.875 |
Batch is a billing and architecture decision. It is a strong fit for offline enrichment, evaluation runs, nightly summaries, document backfills, and other jobs that do not require an immediate response. It is not a substitute for Standard service when a user is waiting in an interactive product flow.
The formula behind Gemini API cost
For a text workload without add-ons, use:
monthly cost =
(input tokens / 1,000,000 × input rate)
+ (output tokens / 1,000,000 × output rate)
If the application uses context caching, add cache-write and storage costs. If it uses grounding, audio, generated images, or generated video, calculate those lines separately because they do not share one universal token rate.
For finance reviews, keep the assumptions beside the result:
| Assumption to record | Why it matters |
|---|---|
| Requests per month | Converts per-request behavior into a budget |
| Average and p95 input tokens | Long prompts can trigger higher Pro pricing |
| Average and p95 output tokens | Output is often the more expensive side |
| Standard versus Batch share | Async work can materially reduce token spend |
| Cache write volume and retention time | Reuse can save input cost but storage is not free |
| Grounded requests | Google Search and Maps have separate allowances and fees |
| Audio, image, and video units | Modality pricing can dominate the text-token bill |
Gemini API free tier versus paid tier
Google shows a free tier for several current Gemini Developer API models. That makes it useful for experiments, prototypes, and low-volume validation. It does not make the production cost question disappear.
The Gemini API billing documentation separates free and paid usage and explains how projects move into paid tiers. Teams should confirm current eligibility, rate limits, data-use terms, and model availability before treating a successful free-tier prototype as production evidence.
The practical distinction is:
- Use the free tier to test prompts, SDK behavior, and product fit.
- Use paid-tier rates and real token telemetry to approve a production budget.
- Do not assume a preview model, a free quota, or a rate limit will remain unchanged through launch.
Gemini Pro pricing and the 200k-token breakpoint
Gemini 2.5 Pro has one of the most important pricing thresholds in the current table. Prompts up to 200k tokens use the lower input and output rates. Prompts above 200k use the higher rates.
That threshold applies to the prompt size of an individual request, not the monthly total. A team sending 20 million tokens in many small prompts can remain on the lower rate, while a lower-volume long-context application can cross the breakpoint repeatedly.
Track at least these two metrics:
- percentage of requests above 200k input tokens
- cost contribution from those requests
If a small share of oversized prompts drives a large share of spend, consider chunking, retrieval, summarization, cache reuse, or a route policy that reserves the long-context model for requests that actually need it.
Context caching, grounding, and modality costs
Token rates are only the base layer of Gemini API pricing.
Context caching
The official table lists a cache-write price and an hourly storage price. Caching can improve economics when the same large context is reused enough times, but the break-even point depends on write volume, retention time, and how much repeated input the cache replaces.
Google Search and Maps grounding
Grounding includes model-specific free allowances followed by per-query or per-prompt charges. Do not estimate a grounded application from token rates alone. Record the number of grounded requests and reconcile them as a separate line item.
Live audio
Live API audio uses different input and output rates from ordinary text calls. Voice-agent teams should budget audio tokens separately and include session duration, interruption behavior, and response verbosity in load tests.
Image and video generation
Generated images and video are priced using modality-specific units and model rows. Treat them as separate production budgets rather than extensions of a text-model estimate.
Gemini Developer API versus Vertex AI and consumer plans
The phrase "Gemini pricing" can refer to several buying paths.
| Product | Typical buyer question | Why it should not be mixed into this table |
|---|---|---|
| Gemini Developer API | What will application calls cost? | This is the rate card summarized in this guide |
| Google AI Studio | Can I prototype and obtain an API key? | It is a development surface, not a separate universal production rate card |
| Vertex AI | How do I operate Gemini inside Google Cloud? | Commercial terms, controls, and service options can differ |
| Consumer Gemini plans | What does an individual subscription include? | Subscription pricing is not API token pricing |
| Gemini Enterprise or Agent Platform | What does a broader enterprise product cost? | It is a different product scope from Developer API calls |
When comparing vendors or gateways, keep the same buying path on both sides. Comparing a consumer subscription with API tokens, or a managed cloud service with a developer API, produces a clean-looking but unusable conclusion.
When direct Google access is enough
Direct Gemini access is often the simplest choice when:
- Gemini is the only model family in production.
- The team is comfortable with Google billing and account structure.
- Engineering does not need cross-provider failover or route abstraction.
- Finance can review usage without consolidating other AI vendors.
An AI API gateway becomes more useful when the operating problem expands beyond one provider:
- the product uses Gemini, GPT, Claude, or other model families
- engineering wants one credential surface and centralized model routing
- finance wants consolidated balances, invoices, or usage review
- operations needs model-level metering and shared policy controls
- teams want to change routes without rebuilding every integration
The gateway does not remove the need to understand underlying model prices. It changes how access, routing, procurement, and reporting are managed around those prices.
Flatkey provides one API access layer for multiple model families. Review the current Flatkey pricing page for the commercial model, then compare the wider model landscape in the AI model pricing comparison.
A recurring Gemini pricing refresh checklist
Pricing pages should have a named source-review owner and a recurring refresh slot. For a high-demand query such as Gemini API pricing, monthly review is a reasonable default, with an immediate review after major Google model announcements.
Use this checklist:
- Compare the model order and lifecycle labels on Google's official pricing page.
- Record new preview, stable, deprecated, and removed model identifiers.
- Verify Standard, Batch, cache-write, and cache-storage rates independently.
- Recheck prompt-length thresholds and whether they affect input, output, or both.
- Verify free-tier availability and billing-tier language.
- Recalculate every workload example from its published assumptions.
- Check grounding, Live API, image, and video sections for separate price changes.
- Confirm internal links, product claims, and the public pricing CTA remain accurate.
- Update the visible "checked on" date only after completing the source review.
The goal is not to promise that a pricing article will never age. The goal is to make every number traceable, every scenario reproducible, and every refresh fast enough to keep the page useful.
The buying decision
Start with workload shape, not the model name.
- Choose the lowest-cost route that meets the task's quality and latency requirements.
- Use Batch for eligible asynchronous work.
- Watch output tokens and long-context breakpoints.
- Budget caching, grounding, audio, image, and video separately.
- Revisit the access architecture when Gemini is no longer the only provider in the stack.
That process turns Gemini API pricing from a static table into a repeatable operating decision.
