Guides / gemini 3.1 flash lite pricing
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 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.
Free, no card, no account
Run the free Cost Leak Scan
It shows your most expensive conversation before you install anything.
Mistakes that cost the most
| Mistake | Why it hurts | Do instead |
|---|---|---|
| Adding a pre-filter without measuring its diversion rate. | The whole case for it rests on how much traffic it keeps away from a dearer model. | Measure what share it actually diverts, then compare that saving against its own cost. |
| Treating guardrail calls as overhead rather than as a feature. | Overhead never gets reviewed, so a filter that stopped earning its place runs indefinitely. | Give the pre-filter its own cost line and review it like anything else. |
| Running the pre-filter on traffic it can't divert. | You pay for a decision on every request while only some requests were ever candidates. | Gate the gate. Run it only where a cheaper deterministic check leaves genuine doubt. |
Run this check tonight
- 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 example
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.
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.
Every number, with its confidence and source
| Figure | What it means | Confidence | Source |
|---|---|---|---|
| $0.25 / $1.50 per million | Gemini 3.1 Flash-Lite input and output rates | calculated | 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 | 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 | $1,225 divided by the $0.011 per-call saving, from the teardown arithmetic at real rates for both models. |
What a generic answer can’t know
A provider bills the filter and the model it guards as the same undifferentiated total. Splitting them, and knowing what share of traffic the filter diverted, needs a tag on each call saying which role it played. Culpa records that on your infrastructure, keeps your prompts and responses there, and counts the calls to run your plan.
Questions founders ask next
How much does Gemini 3.1 Flash-Lite cost?
$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.
Is a cheap pre-filter worth running?
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%.
Why does a cheap model still need metering?
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.
On your infrastructure
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.
How Culpa works
Find the culprit. Not just the total.
Your dashboard shows what you spent. It stops short of who spent it. Culpa shows the conversation, the user and the feature behind it.
Your prompts stay local.
Culpa runs on your own infrastructure. What you send to a model reaches us at no point.
Every dollar has a name.
Follow any charge to the conversation, the user, the feature and the customer behind it.
See the bill before it lands.
Cost your next feature before you ship it. You get the likely bill and the worst case, at best, median, p90 and p99.
Three steps to your first answer.
Change one base URL.
Or drop in the Python or TypeScript library.
Find your most expensive conversation.
In the first session, not the first week.
Cost your next feature before you ship it.
Why the bill went up
Example dashboardCalls traced
418,209
across 3 projects
Spend this week
$378.41
+ $182 vs last week
Failed calls
312
74% retried, and you paid for all of them
+ $182 this week traced to one culprit
Spend over 14 days
Most expensive users
Next week forecast
Graded against reality. Accuracy shown as results land.
Free, no card, no account
Run the free Cost Leak Scan
It shows your most expensive conversation before you install anything.
Keep reading
Sources: Gemini API pricing. Last reviewed 2026-08-01, rates effective 2026-07-02. Plain text version.