Gemini 4 Carbon is Google's frontier reasoning model, generally available since 10 November 2026.
- Input
- text image audio video $2/M
- Output
- text $10/M
- Cache read
- $0.1/M
- Audio input
- $2/M
- Audio cache read
- $0.1/M
- Context
- 1M
- vs GPT-4o
- ~60% cheaper
- Knowledge cutoff
- 2026-03
Rates by prompt length
The whole request uses the rate for its input-length tier. Prices are USD per million tokens.
| Input tokens | Input | Output | Thinking input |
|---|
Benchmarks
Vendor-published: Google
Price in context
Where the price sits among 79 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 | 2026-03 |
Prompt caching
| How it caches | automatic |
|---|---|
| Min prefix | 4,096 |
Thinking
| Vendor control | thinking_level |
|---|---|
| Accepted values | low · medium · high; "minimal" and thinking_budget return 400 |
| Default | medium applied when the request sets nothing |
| Can be turned off | No |
| Thinking behaviour | There is no off setting and no numeric thinking budget. Custom temperature, top_p and top_k values are ignored. |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface; the vendor mapping above applies |
Model
| Modalities | text + image + audio + video → text |
|---|
Google's frontier Gemini 4 model for deep work on complex, real-world tasks across coding, finance, legal, cybersecurity and science. Google says it spends more thinking tokens per turn than Gemini 4 Argon to explore and verify its work, which raises token use and latency. The output price includes thinking tokens. The published rate is introductory: input and output both double on 1 December 2026, and cached input doubles with them. Caching is implicit only.
One prompt, measured through the gateway
Gemini 4 Carbon passed · 3 sentences
Enabling reasoning instructs the AI to generate a lengthy, behind-the-scenes "thought process" to verify its logic before delivering a final answer. Because our vendor bills us based on total output volume, we are charged for all of that invisible scratchpad work in addition to the visible response, effectively doubling the compute consumed per query. Moving forward, we can control this cost by restricting reasoning strictly to complex, high-stakes workflows where higher accuracy justifies the premium, while routing routine tasks back to standard, lower-cost models.
out 908 tok (+799 thinking) latency 18.0 s
Instruction following (exactly three sentences, so countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
Gemini 4 Carbon passed · 8/8 cases
```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 best = max(best, cur) else: cur = 1 return best ``` The original function counts the number of matching adjacent *transitions* rather than the number of *elements* in a run because `best` and `cur` are initialized and reset to `0` instead of `1`. Because a single item on its own already forms a run of length `1`, starting at `0` causes every non-empty result to be short by one: single-element lists (where the loop never executes) and lists with no duplicates return `0` instead of `1`, and any run of $k$ equal items—including one ending at the last index—only increments `cur` $k - 1$ times, making it appear as though the final element of the run was missed. […]
out 1411 tok (+1131 thinking) latency 32.7 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
Gemini 4 Carbon passed · 5/5 fields, guidance null
```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": null, "growth_pct": null, "guidance": null } ```
out 3338 tok (+3281 thinking) latency 61.6 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
Gemini 4 Carbon passed · 120 words, 0 banned, 1 question
Are your engineering teams paying multiple AI vendors to generate identical responses? Today, we are introducing Universal Prompt Caching for our flagship API Gateway. When applications route traffic across providers like OpenAI, Anthropic, and Mistral, duplicate queries drain budgets and degrade user experiences. Our new unified caching layer intercepts incoming prompts directly at the network edge. If an identical request was previously fulfilled by any connected model, the gateway delivers the stored response in milliseconds, completely bypassing external API calls. This practical upgrade cuts monthly token expenses substantially while accelerating overall application speed. Best of all, deployment requires zero complex code changes. Simply activate this capability inside your gateway configuration dashboard today to start reducing latency and infrastructure costs immediately.
out 2620 tok (+2480 thinking) latency 31.1 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use Gemini 4 Carbon 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-4-carbon",
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-4-carbon",
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-4-carbon",
"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-4-carbon",
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-4-carbon")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About Gemini 4 Carbon
- Its official model page describes it as built for deep work on complex, real-world tasks across coding, finance, legal, cybersecurity and science, and Google's what's-new page says that on hard problems it spends more thinking tokens to explore hypotheses, verify its work and check edge cases before responding.
- Gemini 4 Argon shares its context window, built-in tools and per-token price; Google points Carbon at work that needs reasoning depth, such as root-cause debugging, architectural design, dense multimodal synthesis, scientific proofs and security auditing, and keeps Argon as the faster option with lower token spend per turn.
- It accepts text, images, audio, video and PDF input and returns text.
- The context window is one limit of 1,048,576 tokens shared by input and output, and a single synchronous request returns up to 65,536 output tokens (32,768 without streaming).
- Thinking has three levels, low, medium (the default) and high, with no off setting and no numeric thinking budget, so through Synthorai a request that asks for the least reasoning runs at low.
- Google's documentation also says custom temperature, top_p and top_k values are ignored.
- The pricing detail to plan around is that the published rate is introductory rather than settled: $2 per million input tokens and $10 per million output tokens hold through 30 November 2026, and both double on 1 December 2026, to $4 and $20.
- Cached input moves on the same date, from $0.10 to $0.20 per million tokens.
- The output price includes thinking tokens, and Carbon spends more of them per turn than Argon, so budget max output tokens and client timeouts with that in mind.
- Caching is implicit only, for prompts of at least 4,096 tokens: there is no explicit cache to create or manage.
- Synthorai serves it through the OpenAI-compatible chat completions endpoint, so it drops into an existing integration without a Google-specific client.
FAQ
Is the Gemini 4 Carbon API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $2/M input tokens, that credit alone covers roughly 62 requests of ~8K tokens against Gemini 4 Carbon.
What is Gemini 4 Carbon best at?
More thinking per turn than Gemini 4 Argon; one 1M-token limit shared by input and output; introductory pricing doubles on 1 December 2026. See the About section for the full picture from the vendor's own release notes.
How much does Gemini 4 Carbon cost?
Gemini 4 Carbon costs $2 per million input tokens and $10 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Audio input: $2/M tokens · Audio cache read: $0.1/M tokens Cached input tokens bill at $0.1/M.
What is Gemini 4 Carbon's context window?
Gemini 4 Carbon has a context window of 1M tokens on Synthorai. A single response can be up to 65,536 tokens long.
Does Gemini 4 Carbon support prompt caching?
Yes, automatically: Google-served prompts cache with no code changes. Cached input tokens bill at $0.1/M vs $2/M uncached; prompts need a 4,096-token stable prefix to cache. Prompt caching guide →
How do I get access to Gemini 4 Carbon?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="gemini-4-carbon", and you're done. One API key covers every model on the gateway.
What is Gemini 4 Carbon's knowledge cutoff?
Gemini 4 Carbon's knowledge cutoff is 2026-03, per the vendor's official documentation (as of 2026-11-12).
Related models
Compare
Specifications and vendor benchmarks link to their sources. Gateway support describes the Synthorai implementation. Archived examples are individual gateway requests, not a guarantee of general model performance. Prices use the public feed or its build snapshot.