Gemini 2.5 Pro is Google's state-of-the-art thinking model in the 2.5 series, built to reason over complex problems in code, math, and STEM and to analyze large datasets, codebases, and documents using long context.
- Input
- text image video audio $1.25/M
- Output
- text $10/M
- Audio input
- $2.5/M
- Cache read
- $0.125/M
- Context
- 1M
- vs GPT-4o
- ~75% 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 128 to 32768, or -1 for dynamic · Interactions API: low, medium, high |
| Default | dynamic thinking (thinkingBudget -1) applied when the request sets nothing |
| Can be turned off | No |
| Thinking behaviour | Google prints "N/A: Cannot disable thinking" for 2.5 Pro; the floor is 128 tokens, and thinking tokens bill as output tokens. |
| 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 |
|---|
- Stable/GA release of the 2.5 flagship
- 1,048,576-token input / 65,536 output
- text+image+video+audio+PDF input
- thinking supported
One prompt, measured through the gateway
Gemini 2.5 Pro passed · 3 sentences
Enabling reasoning changed the model from a simple Q&A tool into a multi-step problem solver. Instead of answering in one go, it now internally breaks down questions and thinks through steps, with each internal step incurring a charge. This series of computations produces a more accurate answer but requires significantly more processing, which is what doubled our bill.
out 1428 tok (+1359 thinking) latency 14.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 Pro passed · 8/8 cases
Here is the corrected function and an explanation of the bug. ```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: cur = 1 best = max(best, cur) return best ``` The original function's bug stemmed from its counting logic. It initialized the current run length (`cur`) to 0 and only incremented it when a matching *pair* of elements was found. This meant the length of any run was always counted as one less than its actual size (e.g., a run of three `2`s has two matching pairs, so `cur` would only reach 2). […]
out 3286 tok (+2986 thinking) latency 28.1 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Gemini 2.5 Pro passed · 5/5 fields, guidance "Formal guidance is withheld pending the "
```json { "company": "Meridian Robotics", "quarter": "September", "revenue_usd_m": 412, "growth_pct": 11, "guidance": "Formal guidance is withheld pending the Q4 close" } ```
out 1028 tok (+960 thinking) latency 9.1 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Gemini 2.5 Pro passed · 111 words, 0 banned, 1 question
Announcing Cross-Provider Prompt Caching, a new feature for our API Gateway designed for maximum efficiency and cost savings. This capability intelligently stores the response for a given prompt, making it instantly available for future identical requests across any supported provider, including OpenAI, Anthropic, and Google. By serving results directly from the cache, it dramatically reduces latency for common queries and eliminates redundant API expenditures. Why pay multiple times for the same generative AI result? This provides a central, powerful tool to optimize your AI spending and accelerate application performance. Fine-tune your cache's time-to-live settings for granular control over data freshness. Get started today to build more responsive and economical AI-driven products.
out 2389 tok (+2249 thinking) latency 21.0 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Gemini 2.5 Pro 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-pro",
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-pro",
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-pro",
"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-pro",
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-pro")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Gemini 2.5 Pro
- The 1,048,576-token context window and 65,536-token output limit pair with audio, image, video, text, and PDF input, with text output.
- It supports function calling, structured outputs, code execution, Search and Maps grounding, URL context, file search, context caching, and the Batch API; Live API, computer use, image generation, audio generation, and Priority inference are not supported, which is one practical reason to send latency-critical traffic to 2.5 Flash instead.
- Thinking is where Pro differs most from its siblings: thinkingBudget runs from 128 to 32,768 and cannot be set to 0, so reasoning cannot be turned off and every request carries a thinking-token floor billed at the output rate.
- Left unset, the budget is dynamic and the model scales its own reasoning to the problem; Google's newer Interactions API expresses the same control as a thinking_level string.
- One request-shaping habit carries across the current Gemini surface: a request that ends on a non-empty model turn is rejected, so steer output with system instructions or structured outputs rather than prefilling an answer.
- The knowledge cutoff is January 2025.
- On Synthorai it answers through the standard OpenAI-compatible chat completions route.
FAQ
Is the Gemini 2.5 Pro API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $1.25/M input tokens, that credit alone covers roughly 99 requests of ~8K tokens against Gemini 2.5 Pro.
What is Gemini 2.5 Pro best at?
State-of-the-art thinking for code, math, STEM; analyzes large codebases using long context; 1,048,576-token context with PDF input. See the About section for the full picture from the vendor's own release notes.
How much does Gemini 2.5 Pro cost?
Gemini 2.5 Pro costs $1.25 per million input tokens and $10 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.125/M.
Does Gemini 2.5 Pro support prompt caching?
Yes: automatic caching is on by default, with an explicit mode for guaranteed savings. Cached input tokens bill at $0.125/M vs $1.25/M uncached; prompts need a 4,096-token stable prefix to cache. Prompt caching guide →
How do I get access to Gemini 2.5 Pro?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="gemini-2.5-pro", and you're done. One API key covers every model on the gateway.
What is Gemini 2.5 Pro's knowledge cutoff?
Gemini 2.5 Pro'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.