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 — Google replaced thinking_budget with thinking_level in its own API (through our gateway the depth has a different parameter name, see below).

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.

Reasoning depth: reasoning_effort, not thinking_level

This is the API change that matters. Reasoning depth used to be a token count (thinking_budget); now it is a string enum thinking_level with low, medium (default) and high. That is the name in Google's own API — the thinking_budget → thinking_level migration is for people calling Gemini directly.

Through our gateway the name is different. GPTunneL speaks the OpenAI-compatible dialect, so it takes the depth in reasoning_effort:

curl https://gptunnel.ru/v1/chat/completions \
  -H "Authorization: <YOUR_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.7-flash",
    "reasoning_effort": "low",
    "messages": [{"role": "user", "content": "<task>"}]
  }'

Measurement. The same arithmetic task, three runs per level, counting completion_tokens:

Threefold and monotonic — the parameter works. Google's thinking_level in the request body, on the other hand, does nothing: on the same task low gave 1017, 896, 935 and high gave 1008, 908, 617, with the spread inside a level wider than the gap between levels. And you get no error to warn you: minimal, which the native Gemini API rejects with a validation error, is accepted here and answered normally. The field is simply ignored.

What to remember: in code that targets GPTunneL use reasoning_effort, and keep thinking_level for direct calls to Google. Verify the effect through completion_tokens in usage rather than through the vendor's docs: on gpt-5.2 the same reasoning_effort produced a spread that swallowed the gap between levels, so behaviour differs from model to model. The answer, for the record, was correct at every level — on this task depth only moved the bill.

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 depth is called reasoning_effort (see above); the gateway silently ignores Google's thinking_level, which makes it easy to burn three times the tokens you planned for.

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 in Google's API, 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.