# Gemini 3.1 Flash-Lite pricing, and the cost of calling it first

> Gemini 3.1 Flash-Lite pricing is $0.25 per million input and $1.50 output. Put it in front of every request and it earns out above 2.2% diversion.

URL: https://getculpa.com/gemini-3-1-flash-lite-pricing
Last reviewed: 2026-08-01
Rates effective: 2026-07-02

## Answer
Gemini 3.1 Flash-Lite pricing is $0.25 per million input tokens and $1.50 per million output tokens. Its real cost shows up in call count rather than in rate, because a model this cheap gets put in front of every request as a router or a guardrail. Culpa, a local-first LLM cost, margin, and forecast ledger, counts those pre-filter calls as a feature of their own.

## Why this happens
A cheap model invites a pattern that a costly one never would: calling it on every single request, before the real work starts. Routers, safety checks, intent classifiers and relevance filters all sit in that position. Each one doubles your call count against the traffic it guards, and none of them appear in a feature-level cost review because nobody thinks of a guardrail as a feature. The pattern usually pays, sometimes by a lot, and almost nobody has computed the point at which it starts to.

## What this usually looks like
- A classifier or guardrail runs on every request and has no cost line of its own.
- Call count is roughly double your user-facing request count and nobody has explained the gap.
- The pre-filter was added for quality and its diversion rate has never been measured.
- Nobody can say whether the guardrail saves more than it costs.

## Common mistakes
- Adding a pre-filter without measuring its diversion rate. Why it hurts: The whole case for it rests on how much traffic it keeps away from a dearer model. Do instead: Measure what share it actually diverts, then compare that saving against its own cost.
- Treating guardrail calls as overhead rather than as a feature. Why it hurts: Overhead never gets reviewed, so a filter that stopped earning its place runs indefinitely. Do instead: Give the pre-filter its own cost line and review it like anything else.
- Running the pre-filter on traffic it can't divert. Why it hurts: You pay for a decision on every request while only some requests were ever candidates. Do instead: Gate the gate. Run it only where a cheaper deterministic check leaves genuine doubt.

## Self-check
- Count your pre-filter calls separately from your main model calls for last month.
- Measure the share of requests the filter actually diverts from the dearer model.
- Price the filter's own monthly cost at the rates above.
- Divide that cost by the per-call saving on the model it protects. That's your break-even diversion rate.
- Compare the measured rate against the break-even. Below it, the filter costs you money.

## A pre-filter on five million requests (illustrative)
5 million requests a month, each first passed through Gemini 3.1 Flash-Lite at 800 input and 30 output tokens, guarding Gemini 2.5 Pro at $0.00125 per 1k input and $0.010 output. Volumes are modelled.
  Filter per call: (0.8 x $0.00025) + (0.03 x $0.0015) = $0.0002 + $0.000045 = $0.000245
  5,000,000 filter calls x $0.000245 = $1,225 a month
  A guarded call on 2.5 Pro at 4k in and 600 out: (4 x $0.00125) + (0.6 x $0.010) = $0.005 + $0.006 = $0.011
  Break-even diversion = $1,225 / $0.011 = 111,364 calls, which is 2.2% of the traffic
  At a 40% diversion rate it avoids 2,000,000 calls worth $22,000, against its own $1,225
The filter costs $1,225 a month and breaks even at 2.2% diversion. Above that it's the cheapest thing in the stack and below it a pure loss, and almost nobody knows which side of the line their filter sits on.

## Cost figures
Every figure carries its confidence and its source. No figure on this site is provider-reported.
- $0.25 / $1.50 per million — Gemini 3.1 Flash-Lite input and output rates [calculated] Source: Culpa price book row for gemini/gemini-3.1-flash-lite, $0.00025 and $0.0015 per 1k, effective 2026-07-02, verified against Gemini API pricing. Shown here per million.
- $1,225 — modelled monthly cost of running this model as a pre-filter on 5 million requests [calculated] Source: 5,000,000 x $0.000245 per call, using real Gemini 3.1 Flash-Lite rates per 1k. Request volume and token counts are modelled.
- 2.2% — modelled break-even diversion rate for the pre-filter against a Gemini 2.5 Pro workload [calculated] Source: $1,225 divided by the $0.011 per-call saving, from the teardown arithmetic at real rates for both models.

## FAQ
Q: How much does Gemini 3.1 Flash-Lite cost?
A: $0.25 per million input tokens and $1.50 per million output, with context caching at $0.025 per million, a 90% discount. Rates verified against Google's pricing page.

Q: Is a cheap pre-filter worth running?
A: It depends entirely on the diversion rate. Divide the filter's monthly cost by the per-call saving on the model it guards, and that gives the share of traffic it must divert to break even. On the worked example above it's 2.2%.

Q: Why does a cheap model still need metering?
A: Because it's called on every request rather than on some of them, so its call count is the largest in your stack. The rate makes each call negligible and the volume makes the total real.

## Sources
- Gemini API pricing: https://ai.google.dev/gemini-api/docs/pricing

Run the free Cost Leak Scan: https://app.getculpa.com/scan?source=pseo&slug=gemini-3-1-flash-lite-pricing&cluster=model_pricing

Machine-readable index of every guide: https://getculpa.com/api/pages
Human-readable index of every guide: https://getculpa.com/guides
Site overview: https://app.getculpa.com/llms.txt

Privacy: Culpa runs on your infrastructure. Your prompts and responses never leave it. Culpa counts calls to run your plan, and it fails open, so if it ever breaks your app keeps running.