TL;DR.
Google shipped Gemini 4 Hydrogen on November 12 as the successor to Gemini 3.8 Flash. It costs $1.50 per million input tokens and $7.50 per million output tokens, flat across a 1M-token window. That's twice what Gemini 3.8 Flash charges today ($0.75/$3.75 through December 31), and exactly what Flash will charge from January 1.
On a per-token sticker, Hydrogen looks like a price increase. On a per-task bill, it often isn't:
- A quarter of the cost per task. On Artificial Analysis's Intelligence Index, one index task costs $1.87 on Hydrogen at its default (high) setting, against $7.77 on Flash at high, while scoring 51 against 31. Twice the rate, a quarter of the task.
- But only where Flash was thrashing. On Box's enterprise eval, Hydrogen used about 12% fewer tokens than Flash. At twice the rate, that's 1.76x the cost until December 31. The per-task win depends on how many tokens your tasks actually burn, and that number is yours, not a benchmark's.
- The effort dial moves the bill 11x. From low ($0.29 per task) to xhigh ($3.16). The last step, high to xhigh, costs 12x more per index point than the first, and on Terminal-Bench 4.0 it bought nothing: 54% at both.
- Swapping the model string changes more than the model. Per VentureBeat, Hydrogen defaults to high reasoning where Flash defaulted to medium, rejects
thinking_budgetand theMINIMALlevel, and starts implicit caching at 4,096 tokens.
Below: three charts, the break-even rule, a five-step migration checklist, and hydrocheck.py, 44 lines that tell you which of your workloads should move now, which should move January 1, and which shouldn't move at all.
Prices are Google's list prices as reported on November 12 and 13, 2026. Benchmark costs are Artificial Analysis figures as reported by VentureBeat and Fello AI, not Nadir measurements. The three workloads in hydrocheck.py are illustrative assumptions, not customer data.
What Google shipped.
| Gemini 3.8 Flash | Gemini 4 Hydrogen | |
|---|---|---|
| Input, per 1M tokens | $0.75 until Dec 31, then $1.50 | $1.50 |
| Output, per 1M tokens (incl. thinking) | $3.75 until Dec 31, then $7.50 | $7.50 |
| Cached input, per 1M tokens | $0.075 | $0.075 |
| Batch and Flex | Half of standard | Half of standard |
| Context | 1M input, 64K output | ~1M shared by input, thinking and output |
| Thinking levels | Default medium | low, medium, high (default), xhigh |
| Implicit cache threshold (Google Cloud) | 6,144 tokens | 4,096 tokens |
| Intelligence Index (high) | 31 | 51 |
| Cost per index task (high) | $7.77 | $1.87 |
Google's own numbers, against Flash: about 2.5x faster at the default setting, 57% on Terminal-Bench 4.1 versus 18.2%, and partners reporting 2x to 2.8x faster runs with 12% to 23% lower token usage on graph, SQL and data-heavy workflows. Hydrogen is also rolling out in Search, the Gemini app's auto model selection, Sheets and Antigravity, so a lot of people will be running it before their engineering team decides anything.
Two lines from the pricing that matter more than they look:
No intro promotion. Unlike Flash, Argon and Carbon, Hydrogen's standard rate isn't a promo that doubles later. $1.50/$7.50 is the price. That makes it the first Gemini 4 model you can budget a year on.
A "Contributor" tier at half price. Per VentureBeat, it's invite-only and lets Google use data from participating requests to improve products and train models. Half price is real money. So is a data-processing review. Don't let a cost owner opt in without the second one.
Twice the rate, a quarter of the task.
The gap between the rate card and the bill is the whole story. Flash at high spent so many tokens thinking its way through Artificial Analysis's tasks that it cost 4.2x as much per task as a model with twice its per-token price. Cost per task is price times tokens, and Hydrogen cut the tokens by more than it raised the price.
Three more things the chart shows:
Hydrogen at medium beats every cheap model's best. Index 41 for $0.80, above Haiku 5.5, Muse Ember and GPT-6 Luna at max. It's also 2x to 6x their cost per task. If your traffic passes on Haiku 5.5, Hydrogen isn't a saving. It's an upgrade you pay for. (We compared those three in Ten Cents, Three Cliffs.)
Hydrogen at high matches Argon for a fifth of the cost. 51 against 50, $1.87 against $9.95, and that's before Argon's rate doubles on December 1 (Seven Dates, One Bill has the date). If anything in your stack runs Argon at high for agent work, Hydrogen is the first thing to test.
It isn't the cheapest 51. GPT-6.1 Terra at max scores 51 for $0.96, about half of Hydrogen at high. Hydrogen is about 3.4x faster on output (236 vs 70 tokens per second, per Fello AI's table). So Terra wins batch and Hydrogen wins anything a person is waiting on. Same score, different job.
Each effort step buys less.
Hydrogen ships with four thinking levels and defaults to the third. Read the chart as a price list for intelligence:
| Step | Index gained | Extra cost per task | Cost per point |
|---|---|---|---|
| low to medium | +14 | +$0.51 | $0.036 |
| medium to high | +10 | +$1.07 | $0.107 |
| high to xhigh | +3 | +$1.29 | $0.430 |
The default sits on the steep part of the curve. And xhigh costs 69% more than high for three points. On Terminal-Bench 4.0, Artificial Analysis measured 54% at both, so for agentic terminal work it bought nothing. Google's own docs warn that xhigh "can cause overthinking on simpler prompts." That's the overthinking ratio showing up in a launch post.
The practical point: on Hydrogen, the effort setting is a bigger cost lever than the model choice. Low to xhigh is 10.9x. Hydrogen at high to Flash at high is 4.2x. A team that picks Hydrogen and leaves every call on the default has made the smaller of the two decisions. Our cross-provider effort tutorial covers how the dial maps across Gemini, Claude and GPT.
The break-even moves on January 1.
A benchmark average isn't your workload. What decides your bill is one ratio: how many tokens Hydrogen spends on your task, as a share of what Flash spends on the same task.
For a task where output dominates:
- Through December 31, Hydrogen costs 2x per token, so it's cheaper only if it uses less than half of Flash's tokens.
- From January 1, Flash costs the same per token, so Hydrogen is cheaper whenever it uses fewer tokens at all.
Box's 12% saving and Google's partner range of 12% to 23% all sit between those two lines: more expensive today, cheaper in seven weeks. Artificial Analysis's reasoning-heavy tasks sit well under 0.5, cheaper on day one. And a short call that barely thinks (a classifier, an extractor, a router) sits near 1.0, which means 2x the cost today and about the same in January.
So "should we switch to Hydrogen?" has three answers, and they depend on the workload, not the model.
hydrocheck.py: which workloads move, and when.
hydrocheck.py prices one request per workload on Flash today, Flash after January 1, Hydrogen standard and Hydrogen batch, and finds the token ratio where Hydrogen breaks even. Replace WORKLOADS with your own: requests a month, input tokens, how many of them are cached, output tokens including thinking, and the ratio you measured in a shadow run.
"""hydrocheck.py: should this workload move from Gemini 3.8 Flash to Gemini 4 Hydrogen?
Prices are $ per million tokens: (fresh input, cached input, output incl. thinking).
ratio = Hydrogen's tokens / Flash's tokens on the same task, measured on a shadow sample.
Single-shot calls: the ratio applies to output only. Agent tasks: fewer turns, so it
applies to input and output.
"""
PRICES = {
"flash, now": (0.75, 0.075, 3.75), # intro rate through Dec 31, 2026
"flash, jan 1": (1.50, 0.150, 7.50), # scheduled rate; cache rate assumed to double
"hydrogen": (1.50, 0.075, 7.50),
"hydrogen batch": (0.75, 0.0375, 3.75), # half of standard; needs a 24h-tolerant job
}
WORKLOADS = [ # (name, requests/month, input tok, of which cached, output tok on Flash, ratio, agentic)
("ticket triage", 2_000_000, 1_800, 1_200, 150, 1.00, False),
("table/SQL analysis", 200_000, 6_000, 4_000, 2_500, 0.80, False),
("coding agent task", 20_000, 120_000, 100_000, 18_000, 0.45, True),
]
def cost(price, tin, cached, tout):
p_in, p_cache, p_out = price
return ((tin - cached) * p_in + cached * p_cache + tout * p_out) / 1e6
def per_request(model, tin, cached, tout, ratio, agentic):
if model.startswith("hydrogen"):
tout *= ratio
if agentic:
tin, cached = tin * ratio, cached * ratio
return cost(PRICES[model], tin, cached, tout)
def breakeven(tin, cached, tout, agentic, vs):
lo, hi = 0.0, 3.0 # largest ratio at which hydrogen is no dearer than `vs`
target = per_request(vs, tin, cached, tout, 1, agentic)
for _ in range(50):
mid = (lo + hi) / 2
lo, hi = (mid, hi) if per_request("hydrogen", tin, cached, tout, mid, agentic) <= target else (lo, mid)
return lo
for name, n, tin, cached, tout, ratio, agentic in WORKLOADS:
print(f"\n{name}: {n:,} requests/month, token ratio {ratio:.2f}")
for model in PRICES:
c = per_request(model, tin, cached, tout, ratio, agentic)
print(f" {model:15s} ${c:.5f}/request ${c * n:>9,.0f}/month")
for vs in ("flash, now", "flash, jan 1"):
print(f" hydrogen breaks even vs {vs} at ratio {breakeven(tin, cached, tout, agentic, vs):.2f}")
On the three illustrative workloads:
| Workload | Flash today | Flash from Jan 1 | Hydrogen | Hydrogen batch | Break-even ratio, today / Jan 1 |
|---|---|---|---|---|---|
| Ticket triage, 2M/month, ratio 1.00 | $2,205 | $4,410 | $4,230 | $2,115 | 0.10 / 1.08 |
| Table/SQL analysis, 200K/month, ratio 0.80 | $2,235 | $4,470 | $3,660 | $1,830 | 0.42 / 1.02 |
| Coding agent task, 20K/month, ratio 0.45 | $1,800 | $3,600 | $1,552 | $776 | 0.52 / 1.04 |
How to read it:
Ticket triage: wait. Short, input-heavy, barely any thinking to save. Hydrogen costs 1.9x Flash today and break-even needs a ratio of 0.10, which no model change will deliver. From January 1 it's 4% cheaper than Flash, only because its cached-input rate stays at $0.075 while Flash's (by our assumption) doubles. Moving in December is a $2,000 mistake. If the job tolerates a delay, batch gets it to Flash's current price.
Table/SQL analysis: move January 1. At the partner-reported ratio, Hydrogen costs 64% more than Flash today and 18% less from January 1. The quality case may still justify moving early (Box saw accuracy go from 74% to 79%), but that's a quality decision with a price tag, and you should know the tag.
Coding agent task: move now. Fewer turns means fewer input tokens and fewer output tokens, so the ratio compounds. Hydrogen is 14% cheaper than Flash today and 57% cheaper from January 1.
The ratio of 0.45 for the agent task is our assumption. Measure yours.
A five-step migration checklist.
1. Set the thinking level explicitly before you change the model string. Per VentureBeat, Hydrogen defaults to high where Flash defaulted to medium, and it rejects thinking_budget and MINIMAL. Code that set a budget will error, and code that set nothing will think harder than it used to. Pin the level per call site:
from google import genai
from google.genai import types
client = genai.Client()
def ask(prompt: str, level: str = "medium"):
# Hydrogen rejects thinking_budget; pass a level, and never rely on the default
return client.models.generate_content(
model="gemini-4-hydrogen",
contents=prompt,
config=types.GenerateContentConfig(
thinking_config=types.ThinkingConfig(thinking_level=level),
),
)
2. Map Flash's levels down, not across. A call that ran Flash at medium probably doesn't need Hydrogen at medium. Start one level lower and let the eval move it up. Hydrogen at low (index 27, $0.29 per task) is close to Flash at high (31, $7.77) on Artificial Analysis's index.
3. Shadow before you switch. Run 5% of each workload on both models and record tokens per task, pass rate and p95 latency. The token ratio is the number hydrocheck.py needs, and you can't get it from a launch post. Our qualification protocol applies to Hydrogen unchanged.
4. Re-check your cache hit rate. Implicit caching starts at 4,096 tokens on Google Cloud (Flash: 6,144), so some prompts that never cached will start to. Explicit caching wasn't available at launch, so anything relying on a named cache stays on Flash until it is. And switching a live session's model throws its cache away; see the switch penalty.
5. Cap the output. The 1M window is shared by input, thinking and output, and replies can run to 65,536 tokens by default, per Fello AI's reading of the docs. Set max_output_tokens per call site. A model that thinks harder by default and has more room to do it is how a migration becomes a line item.
Where Nadir fits.
Hydrogen turns one decision into two: which model, and how hard it should think. The table above shows that the second one moves the bill more than the first, and that the right answer differs by workload: a triage call, a SQL call and an agent turn want three different settings.
Nadir makes both choices per request. Send model="auto" and Nadir's trained classifier reads each prompt and returns a model-and-effort decision from the models you've configured, against the quality floor you set on the API key. Each response's metadata reports which model served it and what it cost, so the token ratio stops being an estimate and becomes a column in your logs.
If you'd rather keep calling Google directly, POST /v1/bucket returns simple, medium or complex with a probability for each, and your own code maps the bucket to a model and a thinking level.
Observe mode serves exactly the model you asked for and records what Nadir would have picked. A week of it on your Flash traffic gives you the shapes hydrocheck.py needs before January 1 does the math for you. Hydrogen is a day old, so qualify it on your traffic before adding it to any routing pool, ours included.
On the hosted gateway with your own provider keys, the provider bills you directly and Nadir charges a flat $0.002 per request, with the first 50 requests a month free. On a $0.001 triage call that fee is bigger than the call, so run the numbers on your traffic first. Savings depend on your workload, and nothing in this post forecasts yours.
Start with a free key or estimate your savings from your current model spend.
Conclusion.
Gemini 4 Hydrogen costs twice Flash per token and, on Artificial Analysis's tasks, a quarter of Flash per task. Both numbers are true, and neither is your bill. Your bill is the token ratio on your own tasks, times a rate that changes for Flash on January 1, times an effort setting that moves cost 11x on its own. Agent work with a lot of thinking to save should move now. Data-heavy work should move in January. Short calls should stay put, or go to batch. And whichever model you run, set the thinking level yourself. The default is the expensive part.
Sources: [Google, Introducing Gemini 4 Hydrogen](https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-hydrogen/), November 12, 2026: pricing, context, thinking levels, Terminal-Bench 4.1 and partner speed and token figures, Antigravity Orchestrator result. [VentureBeat, Google launches Gemini 4 Hydrogen](https://venturebeat.com/technology/google-launches-gemini-4-hydrogen-a-faster-smarter-pricier-flash-successor), November 12, 2026: cached, Batch, Flex and Contributor rates, Flash's intro and scheduled rates, Artificial Analysis Intelligence Index v5.0.1 scores and cost per task at every Hydrogen level and for Flash, Haiku 5.5, Luna and Ember, Terminal-Bench 4.0, Box's eval, default-effort and `thinking_budget` changes, caching thresholds. [Fello AI, Gemini 4 Hydrogen: Price, Benchmarks and Who Gets It](https://felloai.com/gemini-4-hydrogen/): Argon, Carbon, Sonnet 5.5 and GPT-6.1 Terra index scores, cost per task and output speed, the xhigh warning, output limits. [9to5Google](https://9to5google.com/2026/11/12/gemini-4-hydrogen-launch/) and [Technology.org](https://www.technology.org/2026/11/13/google-gemini-4-hydrogen-replaces-gemini-3-8-flash-pricing/): launch coverage and availability. Workload shapes, token ratios and the Flash cached rate after January 1 in hydrocheck.py are our illustrative assumptions.