Gemini 3.7 Flash: benchmarks, price and the API call

Google shipped Gemini 3.7 Flash on August 13, 2026 — three weeks after 3.6 Flash. For a developer there are three practical changes: the price dropped by half, coding and agentic benchmarks jumped, and the way you control reasoning changed — thinking_budget was replaced by thinking_level.

Below are the documented specs, the benchmark numbers, and the requests I ran through our gateway before publishing. Everything marked as a measurement is a real API response, not a rewrite of the announcement.

What shipped

The API model id is gemini-3.7-flash. The essentials from the model card:

The minimal value of thinking_level is not available on 3.7 Flash: the native Gemini API returns a validation error for it. The context window is unchanged — the same million tokens as 3.6 Flash.

The minimal request

The GPTunneL API is OpenAI-compatible, so the call is a plain POST /v1/chat/completions. The key goes into Authorization without the Bearer prefix:

curl https://gptunnel.ru/v1/chat/completions \
  -H "Authorization: <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.7-flash",
    "messages": [{"role": "user", "content": "Answer in one word: capital of France?"}]
  }'

The response:

{
  "model": "gemini-3.7-flash",
  "choices": [{"message": {"role": "assistant", "content": "Paris"}, "finish_reason": "stop"}],
  "usage": {
    "prompt_tokens": 11,
    "completion_tokens": 103,
    "total_tokens": 114,
    "prompt_cost": 0.00165,
    "completion_cost": 0.07725,
    "total_cost": 0.0789,
    "prompt_tokens_details": {"cached_tokens": 0}
  }
}

Look at completion_tokens: a single word cost 103 output tokens. This is a reasoning model — thinking tokens count as output and are billed at the output rate. If you sized your budget by the length of the visible answer, redo the math.

The usage field returned by the gateway already carries the cost, so bill against it instead of your own tokenizer estimates.

What the benchmarks show

Google measures 3.7 Flash on long engineering tasks rather than textbook ones. Against 3.6 Flash:

That 43.6% on FrontierCode 1.1 Main is ahead of Claude Sonnet 5 (42.7%) and GPT-5.6 Terra (41.3%). On the legal Harvey LAB-AA suite the model scores 90.7%.

Artificial Analysis puts 3.7 Flash (high) at 56 on its Intelligence Index — four points above 3.6 Flash and just behind GPT-5.6 Terra and Muse Spark 1.2 (57 each). Throughput is around 340 output tokens per second, nearly three times GPT-5.6 Terra, with an average time per task of 1.7 minutes. On the agentic AA-AnalystAgent it passes 60% against 54% for Claude Opus 5 at max effort.

The practical read: the gain lives in long tool-using loops, not in chat quality. If you run an agent that spends an hour fixing tests, you will see it. If you classify support tickets, probably not.

thinking_level instead of thinking_budget

This is the API change that matters. Reasoning depth used to be a token count (thinking_budget); now it is a string enum:

from openai import OpenAI

client = OpenAI(api_key="<YOUR_API_KEY>", base_url="https://gptunnel.ru/v1")

r = client.chat.completions.create(
    model="gemini-3.7-flash",
    messages=[{"role": "user", "content": "Find the race condition in this code: ..."}],
    extra_body={"thinking_level": "high"},
)
print(r.usage.completion_tokens)

Measurement. Through gptunnel.ru/v1 the parameter is accepted without an error but does not change anything. Same combinatorics task, three runs per level: low — 755, 555, 576 output tokens; high — 451, 333, 491. The spread inside one level is wider than the gap between levels, and minimal — which the native Gemini API rejects — is accepted here and answered normally. The field never reaches the model.

What to do about it: do not plan savings around reasoning levels, and measure spend on your own workload. The answer, for the record, was correct in all nine runs.

Streaming and structured output

Streaming works as expected with stream: true. A 300-word answer arrived in 28 chunks. The one non-obvious detail is that the gateway sends : HELLO and : PROCESSING keepalive comments before the first data chunk, and a naive parser chokes on them:

const res = await fetch("https://gptunnel.ru/v1/chat/completions", {
  method: "POST",
  headers: { Authorization: KEY, "Content-Type": "application/json" },
  body: JSON.stringify({ model: "gemini-3.7-flash", stream: true, messages }),
});

for await (const chunk of res.body) {
  for (const line of new TextDecoder().decode(chunk).split("\n")) {
    if (!line.startsWith("data: ")) continue;      // drops ": HELLO" and ": PROCESSING"
    const payload = line.slice(6);
    if (payload === "[DONE]") break;
    process.stdout.write(JSON.parse(payload).choices[0].delta.content ?? "");
  }
}

Structured outputs are there too — response_format with a schema returns valid JSON:

-d '{
  "model": "gemini-3.7-flash",
  "response_format": {"type": "json_schema", "json_schema": {"name": "invoice", "strict": true,
    "schema": {"type": "object", "properties": {"number": {"type": "string"}, "total": {"type": "number"}},
    "required": ["number", "total"], "additionalProperties": false}}},
  "messages": [{"role": "user", "content": "Invoice #A-114 for 25000. Return JSON."}]
}'

Out comes {"number":"A-114","total":25000} for 304 output tokens. Pulling a couple of fields out of a document costs more than the length of the result suggests — again, you pay for the thinking.

What breaks in production

• max_tokens gets eaten by reasoning. Measured: with max_tokens: 16 the model returned finish_reason: "length" and an empty content string while spending 13 output tokens. You pay and get nothing. Set the ceiling with room for reasoning and ask for short answers in the prompt instead.
• Timeouts. At high reasoning the average task takes minutes. A 30-second client timeout will cut off perfectly good answers; use 180 seconds with exponential-backoff retries.
• The 65,536-token output cap. Long document generation has to be chunked on your side.
• cached_tokens in the response. It was zero across my runs; on a repeated system prompt, measure cache savings by that field rather than by the promise.
• Reasoning level is not controllable through the gateway (see above) — budget for the upper bound.

3.7 Flash or 3.1 Pro

A common question when picking a model. In the GPTunneL catalog Gemini 3.1 Pro costs $6.00 per 1M input tokens and $30.00 per 1M output tokens — four times more than 3.7 Flash at the same million-token context. Pro stays the choice for tasks where the depth of a single answer matters most. For agentic loops that call the model hundreds of times in a row, the Flash economics win: 340 tokens per second and a quarter of the bill add up to a different iteration speed.

What it costs

In GPTunneL, Gemini 3.7 Flash is billed per token: $1.50 per 1M input tokens and $7.50 per 1M output tokens, with a 1M-token context. That is exactly half of 3.6 Flash ($3.00 and $15.00), which is still in the catalog. Google itself runs an introductory rate of $0.75 and $3.75 per 1M tokens through the end of 2026, after which the list price is $1.50 and $7.50. Current numbers for every model live on the pricing page.

FAQ

Can I download Gemini 3.7 Flash? No. The Gemini line has no open weights; the model runs only through the API and Google's cloud interfaces. There is no way to self-host it.

Is it the strongest Gemini? It is the strongest in the Flash line, and its Artificial Analysis Index score of 56 puts it next to competing flagships. But Flash is about speed and price: where the depth of a single answer matters most, the Pro line is still ahead.

How is 3.7 Flash different from 3.6 Flash? A jump on coding and agentic benchmarks (DeepSWE 49.0% → 65.3%), the new thinking_level in place of thinking_budget, and half the price. Context and output limits are unchanged.

Do I need a Google Cloud project? Not with GPTunneL: one key works for the whole catalog, there is no subscription, and you are billed for the tokens you actually spend.

Try it yourself

Take a real task — not "write me a poem", but the agentic loop with tools that you currently run on 3.6 Flash. Open Gemini 3.7 Flash in GPTunneL or drop gemini-3.7-flash into your code with base_url=https://gptunnel.ru/v1 and compare two numbers: total_cost and time to a finished result. The benchmarks have been run for you already.