Gemini API pricing for every model tier and service mode in 2026. Compare Standard, Batch, Flex, and Priority costs, plus caching, billing tiers, and add-on fees.
Gemini 3.5 Flash costs $0.75 per million input tokens or $2.70 per million input tokens. Same model, same prompt, same output quality. The difference is the service mode: Batch versus Priority. That 3.6x spread is the single largest cost lever in gemini api pricing, and most pricing guides skip right past it to compare models.
Model selection matters, but routing strategy matters more. A request that can tolerate a few minutes of latency costs half as much in Batch mode as it does in Standard. A request that needs guaranteed low latency costs 80% more in Priority. The economics shift depending on how you dispatch, not what you dispatch to.
Google structures gemini api pricing around four service modes. Each mode applies to the same underlying model but changes the cost and latency profile.
Taking Gemini 3.5 Flash as the reference point:
| Service Mode | Input (per 1M tokens) | Output (per 1M tokens) | Cost vs. Standard |
|---|---|---|---|
| Batch | $0.75 | $4.50 | 50% less |
| Flex | $0.75 | $4.50 | 50% less |
| Standard | $1.50 | $9.00 | Baseline |
| Priority | $2.70 | $16.20 | 80% more |
Batch and Flex both carry a 50% cost reduction over Standard. Priority guarantees capacity and lower latency at a premium. The output token spread is even wider in absolute terms: $4.50 versus $16.20 per million output tokens.
For workloads like bulk classification, document summarization, or nightly report generation, Batch pricing cuts your bill in half with zero changes to the prompt or model. For user-facing chat where latency is the constraint, Priority ensures you get capacity when you need it. Standard sits in between for general-purpose use.
Four models carry published gemini api pricing as of mid-2026. They span a wide cost range depending on the task.
Gemini 3.1 Flash-Lite is the cheapest option at $0.25/M input and $1.50/M output for text, image, and video. Google describes it as optimized for high-volume agentic tasks, translation, and simple data processing. Audio input carries a surcharge: $0.50/M tokens, double the text rate. Batch mode drops Flash-Lite to $0.125/M input and $0.75/M output.
Gemini 3.5 Flash is the flagship speed model at $1.50/M input and $9.00/M output in Standard mode, with the full spread of service modes described above.
Gemini 3.1 Pro Preview sits at $2.00/M input and $12.00/M output in Standard mode, with Batch at $1.00/$6.00. The most expensive per-token option in the lineup, aimed at tasks where reasoning depth justifies the premium.
Gemini 3.5 Live Translate is a specialized real-time speech-to-speech model supporting 70+ languages, priced at $3.50/M input tokens or $0.0053/min for audio input, and $21.00/M output tokens or $0.0315/min for audio output.
For comparison, OpenAI's GPT-4o and Claude's Sonnet occupy similar price bands for their respective mid-tier models, though the service mode structure is unique to Google's approach.
Google offers three tiers: Free, Paid, and Enterprise. The Free tier is not just a rate-limited version of Paid. The differences are structural.
The most consequential: Free tier data is used to improve Google products; Paid tier data is not. For any production workload handling customer data, this alone forces the upgrade.
Feature access also differs. The Batch API, which carries the 50% cost reduction, is not available on the Free tier. Context caching is free-tier accessible but without the cost savings that make it meaningful at scale. Grounding with Google Search is only available on Paid.
Upgrading requires linking a billing account and prepaying a minimum of $10 in credits. That $10 unlocks Tier 1 billing.
Once on the Paid tier, your spending cap increases as you build history with Google. The billing tiers progress as follows:
| Tier | Qualification | Billing Cap |
|---|---|---|
| Free | Active project or free trial | N/A |
| Tier 1 | Linked billing account | $250 |
| Tier 2 | Paid $100 + 3 days from first payment | $2,000 |
| Tier 3 | Paid $1,000 + 30 days from first payment | $20,000 to $100,000+ |
The qualification criteria are cumulative spend plus account age. You cannot skip tiers by paying more upfront. A new production deployment that expects to process $5,000/month in API calls will hit the $250 cap on Tier 1 within days and need to wait for Tier 2 qualification.
Plan for this ramp. If you are migrating a workload from another provider, the billing tier progression means you cannot move all traffic on day one.
Implicit context caching is enabled by default for all Gemini 2.5+ models and newer. Google passes cost savings automatically when your request hits a cache. You do not need to change any code to benefit.
The savings are substantial. For Gemini 3.5 Flash, cached input costs $0.15/M tokens versus $1.50/M for uncached input. That is a 90% reduction on the input side. Storage costs $1.00/M tokens per hour.
Minimum token thresholds determine whether caching activates. Gemini 3.5 Flash and 3.1 Pro require 4,096 input tokens; Gemini 2.5 Flash and Pro require 2,048 tokens. Requests below these thresholds will not benefit from caching regardless of repetition.
For applications that send repeated system prompts or long context windows (RAG pipelines, document Q&A, multi-turn conversations with large context), implicit caching can reduce effective input costs dramatically without any architectural change.
Two add-ons deserve attention because they sit outside the per-token model.
Grounding with Google Search costs $14 per 1,000 search queries after the first 5,000 free prompts per month. The free allowance is shared across Gemini 3 models. A product that grounds every response in web search at 50,000 queries/month would add $630/month on top of token costs. Whether grounding is worth that depends on your hallucination tolerance, but the cost is easy to overlook during prototyping when you are still under the 5,000 free threshold.
Audio input surcharges apply to Flash-Lite: $0.50/M tokens for audio versus $0.25/M for text, doubling the input cost. Live Translate has its own per-minute billing structure entirely.
When standard gemini api pricing no longer fits, the Enterprise tier adds:
Enterprise pricing is not published. It is negotiated based on usage volume and requirements. The decision point is usually either compliance (you need contractual guarantees that Paid tier does not offer) or throughput (you need guaranteed capacity beyond what Tier 3 rate limits provide).
Before jumping to Enterprise, evaluate whether Batch mode plus implicit caching already solves your cost problem. If 60% of your requests can tolerate async processing, the 50% Batch discount combined with 90% caching savings on repeated context may bring costs below what you would negotiate on an Enterprise contract.
The Anthropic and OpenAI pricing pages present a simpler structure: pick a model, pay per token. Google's service mode system adds a dimension that most teams underutilize.
Consider a workload processing 100 million input tokens per month on Gemini 3.5 Flash. At Standard pricing, that is $150/month in input costs. Route 70% of those requests through Batch (the portion that does not need real-time response), keep 25% on Standard, and push 5% to Priority for latency-sensitive paths:
That is a 31% reduction before caching enters the picture. Layer implicit caching on top (assuming 40% cache hit rate on the Standard and Priority traffic, dropping input cost to $0.15/M on those hits), and the savings compound further.
The challenge is that this routing logic does not exist inside the Gemini API itself. You need an LLM proxy or gateway layer that inspects each request, classifies its latency tolerance, and dispatches it to the appropriate service mode. Teams running multi-provider setups across Gemini, OpenAI, and Claude benefit from a single routing layer that handles this dispatch alongside provider failover and spend tracking.
Choose Gemini's Batch, Standard, or Priority mode explicitly in the native Gemini request. SHIM forwards native Gemini generateContent and streamGenerateContent calls; it does not select service modes or add semantic caching.