Gemini 3.5 Flash vs 3.1 Pro API: Cost, Quality and Routing

Last updated: August 6, 2026

If you are comparing Gemini 3.5 Flash vs 3.1 Pro, start with gemini-3.5-flash for production traffic and promote only the tasks that prove they need gemini-3.1-pro-preview. In LumeAPI's catalog, Flash costs $0.75 input and $4.50 output per million tokens; Pro Preview costs $1.00 and $6.00. Pro therefore costs 33.3% more for the same input/output mix. The model name gemini-3.5-pro is not in Google's current public Gemini API catalog.

LumeAPI is an independent third-party API gateway, not Google. Prices, availability and compatible parameters can change, so the dated catalog values and exact IDs below should be checked again before a production rollout.

Short path: Check the current Gemini API catalog, copy an exact ID from all models, and use the decision test below before sending all traffic to Pro.

Quick Answer

The safe default is Flash, not because “Flash is always faster” or “Pro is always better,” but because the current price and benchmark evidence make model choice workload-dependent. Measure success per completed task, not per response.

In short

Gemini 3.5 Flash is the current stable 3.5 text-output model in Google's public Gemini API list, while Gemini 3.1 Pro remains a preview Pro model. On the LumeAPI text route, the exact IDs are gemini-3.5-flash and gemini-3.1-pro-preview. At a representative 2,000-input/500-output-token request, Flash costs about $0.00375 and Pro about $0.00500. Pro must improve the accepted-result rate by 33.3% relative to Flash just to break even on model cost.

Does Gemini 3.5 Pro exist?

As of August 6, 2026, Google's public Gemini model list contains gemini-3.5-flash, gemini-3.5-flash-lite, and gemini-3.1-pro-preview; it does not list gemini-3.5-pro. A user may type “Gemini 3.5 Pro” because 3.5 is the newer family number and Pro is a familiar tier, but an application must not silently convert that phrase into a model ID.

Use a model-list request during deployment and fail closed when an ID is missing:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["LUMEAPI_KEY"],
    base_url="https://api.lumeapi.site/v1",
    timeout=30.0,
    max_retries=0,
)

available = {model.id for model in client.models.list().data}
requested = os.environ.get("GEMINI_MODEL", "gemini-3.5-flash")
if requested not in available:
    raise RuntimeError(f"Unavailable model id: {requested}")

This guard prevents a typo, retirement or invented version from becoming a hidden fallback. If your application intentionally supports fallback, map it in version-controlled policy and log the substitution.

Price comparison on the same workload

The rates below were checked against LumeAPI's public catalog on August 6, 2026. They are per one million input/output tokens.

For a request with 2,000 input tokens and 500 output tokens:

• Flash: (2,000 × $0.75 + 500 × $4.50) / 1,000,000 = $0.00375
• Pro: (2,000 × $1.00 + 500 × $6.00) / 1,000,000 = $0.00500
• Pro premium: $0.00500 / $0.00375 - 1 = 33.3%

For 10 million input and 2 million output tokens, the same mix costs $16.50 on Flash and $22.00 on Pro. These calculations exclude retries, caching, tools, gateway minimums and any route-specific charges. Use actual usage records rather than prompt-character estimates for billing forecasts.

The accepted-result break-even rule

Token price is not the final cost. The useful metric is:

cost per accepted result = total model spend / accepted outputs

If both models use the same token mix, Pro breaks even only when:

Pro acceptance rate >= Flash acceptance rate × 1.333

This is the first decision module that generic price lists omit: when Flash already succeeds on most tasks, a 33.3% rate premium is difficult to recover. Conversely, if a difficult workflow fails half the time on Flash, Pro may reduce retries and human review enough to lower the total cost.

What Google's benchmarks do and do not show

Google's May 2026 Gemini 3.5 Flash model card reports 76.2% for Flash versus 70.3% for 3.1 Pro on Terminal-Bench 2.1, 55.1% versus 54.2% on SWE-Bench Pro, and 83.6% versus 78.2% on MCP Atlas. The same card reports Pro ahead on Humanity's Last Exam (44.4% versus 40.2%), ARC-AGI-2 (77.1% versus 72.1%), and the 128K MRCR long-context evaluation (84.9% versus 77.3%).

These are provider-reported benchmark results under specific harnesses. They do not predict your prompts, repositories, languages, tool schemas or latency. Their useful lesson is narrower: the tier name “Pro” is not proof that 3.1 Pro will beat the newer 3.5 Flash on every task. They justify testing, not a universal winner.

Use this production decision matrix

Do not combine all these tasks into one average score. A model can win extraction and lose reasoning. Route by task class only after every class has its own acceptance rule.

Run a same-task evaluation

Build a frozen set of at least 50 representative cases for a narrow task. One hundred or more cases are preferable when errors are rare or business impact is high.

1. Remove secrets and personally identifiable data.
2. Define an acceptance rubric before running either model.
3. Keep prompts, tools, temperature, token limits and retry policy fixed.
4. Randomize output order before human review where practical.
5. Record input tokens, output tokens, attempts, latency and accepted/rejected status.
6. Calculate cost per accepted result and the 95th-percentile user latency.
7. Promote Pro only for a task class where the total outcome improves.

Use the calculator below with measured token counts and acceptance rates:

from dataclasses import dataclass

@dataclass(frozen=True)
class Route:
    name: str
    input_per_million: float
    output_per_million: float
    acceptance_rate: float


def cost_per_accepted(route: Route, input_tokens: int, output_tokens: int) -> float:
    if not 0 < route.acceptance_rate <= 1:
        raise ValueError("acceptance_rate must be between 0 and 1")
    attempt = (
        input_tokens * route.input_per_million
        + output_tokens * route.output_per_million
    ) / 1_000_000
    return attempt / route.acceptance_rate


flash = Route("gemini-3.5-flash", 0.75, 4.50, 0.72)
pro = Route("gemini-3.1-pro-preview", 1.00, 6.00, 0.90)

for route in (flash, pro):
    print(route.name, round(cost_per_accepted(route, 2_000, 500), 6))

With these illustrative acceptance rates, Flash is about $0.005208 per accepted result and Pro about $0.005556. Pro produces more accepted outputs but still costs more per success. Replace the example rates with your measured results; they are not claims about model quality.

A practical routing policy

A production policy can start every eligible task on Flash, then route selected classes to Pro based on an offline evaluation—not on the model grading itself.

ROUTES = {
    "interactive_chat": "gemini-3.5-flash",
    "structured_extraction": "gemini-3.5-flash",
    "verified_long_context": "gemini-3.1-pro-preview",
}


def choose_model(task_class: str) -> str:
    try:
        return ROUTES[task_class]
    except KeyError as exc:
        raise ValueError(f"Unapproved task class: {task_class}") from exc

Keep this policy explicit. Avoid “ask Flash, then ask Pro whenever Flash sounds uncertain”: self-reported confidence is often poorly calibrated, and a second call can double both latency and token use. Prefer deterministic signals such as document length, task class, tool count or a validated lightweight classifier.

Call either model through one client

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["LUMEAPI_KEY"],
    base_url="https://api.lumeapi.site/v1",
    timeout=45.0,
)

response = client.chat.completions.create(
    model="gemini-3.5-flash",
    messages=[
        {"role": "system", "content": "Answer with concise, verifiable steps."},
        {"role": "user", "content": "Summarize the migration risks in this change."},
    ],
    max_tokens=500,
)

print(response.choices[0].message.content)
print(response.usage)

Changing the model string reuses the compatible request shape, but it does not guarantee every Google-native feature or parameter is exposed identically through a third-party route. Test function calling, structured output, multimodal input and thinking controls against the exact LumeAPI model before relying on them.

A realistic production scenario

A software team processes 100,000 pull-request summaries per month at an average of 2,000 input and 500 output tokens. If every task runs once, the simplified model spend is about $375 on Flash or $500 on Pro. In a 100-case blinded evaluation, suppose Flash achieves 72 accepted summaries and Pro achieves 90. Cost per accepted result is then approximately $0.00521 for Flash and $0.00556 for Pro.

If the eight percentage points of additional accepted output above the break-even threshold save expensive reviewer time, Pro may still be the correct business choice. If reviewers already glance at every summary, Flash may deliver nearly the same workflow result for less. The decision depends on downstream labor and error severity, not token price alone.

What most guides get wrong

Many comparisons copy provider benchmark tables, label Pro “best quality,” label Flash “best speed,” and stop. That does not answer the production question. It ignores current model IDs, preview lifecycle risk, output-heavy pricing, retry volume and the acceptance rate needed to justify an upgrade. It also treats benchmark rank as transferable to every user task.

The more useful comparison normalizes one workload, defines accepted output, includes all attempts, and publishes the promotion threshold before seeing results.

Expert take

Use gemini-3.5-flash as the baseline route because it is cheaper and Google's own published results show it can outperform 3.1 Pro on several coding and agentic evaluations. Keep gemini-3.1-pro-preview as a measured exception for task classes where it wins on accepted-result cost or high-severity accuracy. Never deploy the nonexistent gemini-3.5-pro string because a search query sounds plausible.

FAQ

Is Gemini 3.5 Flash better than Gemini 3.1 Pro?

Not universally. Google reports Flash ahead on several agentic and coding benchmarks and Pro ahead on some academic reasoning and long-context benchmarks. Test the task you actually run.

Which is cheaper through LumeAPI?

At the catalog rates checked August 6, 2026, Flash is $0.75/$4.50 per million input/output tokens and Pro is $1.00/$6.00. Pro is 33.3% more for the same token mix.

Is there a Gemini 3.5 Pro API model?

Google's current public model list does not show gemini-3.5-pro. Use a model-list call and exact current IDs rather than guessing.

Should I route to Pro after a Flash failure?

Only for defined, retry-safe failure classes. Blind escalation can duplicate side effects and inflate latency. Prefer offline task classification and idempotent workflows.

Does one OpenAI-compatible request mean every feature is identical?

No. The compatible text envelope reduces integration changes, but native Gemini features and route-specific parameters still require exact-model testing.

Sources and verification

• Google Gemini API model list for current public model names, IDs and lifecycle labels.
• Google DeepMind Gemini 3.5 Flash model card for dated capabilities, limitations and benchmark results.
• LumeAPI Gemini 3.5 Flash model page and Gemini 3.1 Pro model page for current gateway IDs, endpoint and catalog pricing.
• Gemini API Python guide for a focused integration walkthrough.

The three Python blocks were syntax-checked on August 6, 2026. Price calculations are reproducible arithmetic using the displayed rates. No live key, paid inference run or unpublished latency measurement was used, and benchmark results remain provider-reported rather than independent LumeAPI tests.