Gemini 2.5 Flash is Google's best price-performance Gemini 2.5 model, aimed at low-latency, high-volume workloads that still require reasoning, including large-scale processing and agentic applications.
- Input
- text image video audio $0.3/M
- Output
- text $2.5/M
- Audio input
- $1/M
- Cache read
- $0.03/M
- Context
- 1M
- vs GPT-4o
- ~94% cheaper
- Knowledge cutoff
- 2025-01
Benchmarks
Vendor-published: Alibaba (Qwen) Amazon Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Price in context
Where the price sits among 60 comparable models
The bar shows how this model’s price compares with every other model of the same kind on Synthorai. The cheapest and the most expensive are named at each end. These are base rates; batch, region and cache-write discounts are on the pricing page.
Specs & limits
Tokens
| Context window (vendor spec) | 1,048,576 |
|---|---|
| Max output (vendor spec) | 65,536 |
| Knowledge cutoff | 2025-01 |
Prompt caching
| How it caches | automatic + explicit |
|---|---|
| Min prefix | 4,096 |
Thinking
| Vendor control | thinkingBudget (generateContent) · thinking_level (Interactions API) |
|---|---|
| Accepted values | thinkingBudget 0 to 24576, or -1 for dynamic · Interactions API: low, medium, high |
| Default | dynamic thinking (thinkingBudget -1) applied when the request sets nothing |
| Can be turned off | Yes |
| Thinking behaviour | thinkingBudget 0 turns thinking off; thinking tokens are billed as output tokens (thoughtsTokenCount); 2.5 returns thought signatures only when thinking is on and the request declares functions. |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface - the vendor mapping above applies |
Model
| Modalities | text + image + video + audio → text |
|---|
- First stable 2.5 Flash release
- 1,048,576-token input / 65,536 output
- text+image+video+audio input
- thinking supported
One prompt, measured through the gateway
Gemini 2.5 Flash passed · 3 sentences
Enabling LLM reasoning means the model processes more complex thoughts, often requiring multiple steps or internal iterations to generate accurate answers. This translates directly to higher token consumption per query, as the model "thinks" more deeply and generates more internal and external text for each request. While increasing cost, this deeper processing significantly enhances output quality and reliability, delivering more robust solutions for critical business functions.
out 368 tok (+290 thinking) latency 3.1 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Gemini 2.5 Flash passed · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = 1 # Initialize best to 1, as a non-empty list always has at least one run of length 1 cur = 1 # Initialize current run length to 1 for the first element for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 # Extend the current run else: cur = 1 # Start a new run of length 1 with the current element xs[i] best = max(best, cur) # Always update best after processing the current element return best ``` **Explanation of the bug:** The original code had two primary flaws. First, it initialized `best` to 0 and `cur` to 0. For single-element inputs (e.g., `[1]`), the loop `range(1, len(xs))` would be empty, causing the function to incorrectly return 0 instead of 1. […]
out 3871 tok (+3463 thinking) latency 19.8 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Gemini 2.5 Flash passed · 5/5 fields, guidance "withheld pending the Q4 close for Meridi"
```json { "company": null, "quarter": "September", "revenue_usd_m": 412, "growth_pct": 11, "guidance": "withheld pending the Q4 close for Meridian Robotics" } ```
out 380 tok (+314 thinking) latency 2.5 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Gemini 2.5 Flash passed · 111 words, 0 banned, 1 question
Introducing our latest API Gateway enhancement: **Cross-Provider Prompt Caching**. This new feature intelligently stores and reuses frequently used prompts across all your integrated AI services, regardless of the underlying provider. Eliminate redundant API calls and unnecessary expenses from sending identical requests repeatedly. By intelligently serving cached responses, your applications will experience significantly reduced latency and improved operational efficiency, leading to faster user interactions. This update ensures consistent, rapid delivery of AI-generated content, optimizing resource utilization across your entire AI infrastructure. Are you ready to accelerate your AI-driven workflows and reduce operational spend? Experience substantial performance gains and smarter resource management with this advanced capability, bolstering your AI strategy for greater effectiveness.
out 1242 tok (+1108 thinking) latency 7.3 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Gemini 2.5 Flash in 30 seconds
OpenAI-compatible: swap the base_url, keep your SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="gemini-2.5-flash",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "gemini-2.5-flash",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "gemini-2.5-flash",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "gemini-2.5-flash",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("gemini-2.5-flash")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Gemini 2.5 Flash
- Google's model page calls it the "best model in terms of price-performance, offering well-rounded capabilities," the middle pick between Flash-Lite, which gives up reasoning depth for cost, and 2.5 Pro, which gives up latency for depth.
- It is a thinking model with a 1,048,576-token context window and 65,536-token output limit, accepting text, image, video, and audio input and returning text.
- Supported capabilities include function calling, structured outputs, code execution, Search and Maps grounding, URL context, context caching, the Batch API, and Flex and Priority inference; Live API, image generation, audio generation, and computer use are not.
- Thinking runs dynamically by default, and 2.5 Flash is one of the few Gemini models where it can be switched off outright: thinkingBudget accepts 0 through 24,576, with -1 for dynamic and 0 disabling thinking entirely.
- That setting is worth choosing deliberately, because thinking tokens bill as output tokens even when only a summary is returned.
- Google's newer Interactions API exposes the same control as a thinking_level string at low, medium, or high instead of a numeric budget, so which surface you call changes how you ask.
- The knowledge cutoff is January 2025.
- Developers reach it on Synthorai through the familiar OpenAI-compatible chat completions API.
FAQ
Is the Gemini 2.5 Flash API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $0.3/M input tokens, that credit alone covers roughly 416 requests of ~8K tokens against Gemini 2.5 Flash.
What is Gemini 2.5 Flash best at?
Best price-performance for high-volume reasoning; thinking model with 1,048,576-token context; code execution and search grounding built in. See the About section for the full picture from the vendor's own release notes.
How much does Gemini 2.5 Flash cost?
Gemini 2.5 Flash costs $0.3 per million input tokens and $2.5 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.03/M.
Does Gemini 2.5 Flash support prompt caching?
Yes: automatic caching is on by default, with an explicit mode for guaranteed savings. Cached input tokens bill at $0.03/M vs $0.3/M uncached; prompts need a 4,096-token stable prefix to cache. Prompt caching guide →
How do I get access to Gemini 2.5 Flash?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="gemini-2.5-flash", and you're done. One API key covers every model on the gateway.
What is Gemini 2.5 Flash's knowledge cutoff?
Gemini 2.5 Flash's knowledge cutoff is 2025-01, per the vendor's official documentation (as of 2026-07-09).
Related models
Compare
Every value on this page is transcribed from the vendor's own documentation, linked above, and carries the date it was checked. Prices are compared across the catalogue; specification values that vendors define differently are shown with the difference stated rather than charted. Nothing here is measured by us, and nothing is scored.