Gemini 4 Hydrogen API: Estimated Cost of 1,000 Tool Calls, Model Tokens Plus Data Calls
Gemini 4 Hydrogen API: estimated cost of 1,000 tool calls in tokens and API fees. From 10 live data calls: $6.14 with parallel calls, trimming and cache.

Google released Gemini 4 Hydrogen on November 12, 2026. The model code is gemini-4-hydrogen. The AI Studio pricing page lists $1.50 per million input tokens and $7.50 per million output tokens. The price is the same across the full one-million-token context. The free tier can use it too.
Google positions it as the fast model for everyday coding and tool use. We wanted to answer one practical question. Suppose the model gets six functions that call the EveryInfra web search, news, Reddit and YouTube APIs. It then checks what people say about Hydrogen pricing this week. How much do 1,000 tool calls cost, and does the money go to model tokens or to the data calls?
On 2026-11-19, from 00:23 to 00:31 Singapore time (SGT), we made 10 live data calls in three rounds. They cost $0.007877 in total. We then used the real size of each response to estimate the model cost. We did not run the model side. For 1,000 tool calls, the naive method costs $22.82. In that method, the model calls one tool per turn and gets the full response each time.
The optimized method costs $6.14. It trims each response to the fields the model needs, lets the model call independent tools in the same turn, and uses implicit caching. The same optimized method on Gemini 4 Carbon at its December 1 price costs $14.94. In all three cases, the data calls cost $0.85.
We do not have a Gemini API key. So we did not run the model side on our machine. The Gemini parameters and code in this article follow the Google AI Studio documentation and are configuration examples. We estimated token counts from the real character counts of the data responses. We used the Google rule of thumb of "about 4 characters per token", and we mark each estimate.
Every number on the data side traces back to the response body of one live call. Our November article on the Gemini Decisions API covers Gemini Decision 1 and structured decisions. This article is different. It covers how a low-cost fast model runs a multi-step tool loop, and how to count the two costs.
Gemini 4 Hydrogen API: the fast model from November 12
The launch post on blog.google calls Hydrogen the fast Gemini 4 model for everyone. It is the default model in the Gemini app and in AI Mode in Search. Developers can call it through the Gemini API, AI Studio and the enterprise Agent Platform. The post gives a score of 51 on the Artificial Analysis Intelligence Index.
Gemini 4 Argon, released four weeks earlier, scores 50. On Terminal-Bench 4.1, Hydrogen scores 57%, against 18.2% for Gemini 3.8 Flash. Google says it is 2.5 times faster than 3.8 Flash and makes over five times fewer fabricated claims.
The launch post also says Hydrogen adapts cleanly when a tool call fails or a search returns nothing. In a check across four sources, one source often has no data. The model must continue without it.
The AI Studio model page lists the supported features. Function calling, structured outputs, grounding with Google Search and Google Maps (the model runs a search and then answers), URL context, code execution and computer use are all supported. The context window is 1,048,576 tokens, shared by input, thinking and output. One synchronous response can have up to 65,536 output tokens by default.
With long decode, a mode for very long output, the output can grow to one million tokens. Only implicit caching is supported. With implicit caching, the API finds a repeated prompt prefix and bills it at the cached price. You do not create the cache yourself. Explicit caching with cachedContents is not supported.
There are four thinking levels: low, medium, high (the default) and the new xhigh. A request with minimal returns an error. The "What's new" page names Hydrogen as the recommended upgrade from 3.8 Flash and older Gemini 3 and 2.5 models. It is also the default model for the Antigravity agent in Managed Agents.
| Item | Gemini 4 Hydrogen | Source |
|---|---|---|
| Model code | gemini-4-hydrogen | AI Studio model page |
| Context | 1,048,576 tokens, shared by input, thinking and output | Model page, long decode page |
| Output per response | 65,536 by default, up to 1,048,576 with long decode | Model page |
| Thinking levels | low, medium, high (default), xhigh. No minimal | What's new page |
| Caching | Implicit only. A prefix needs at least 4,096 tokens | Caching page |
| Tools | Function calling, structured outputs, Search and Maps grounding, URL context, code execution, computer use, remote MCP | Model page, function calling page |
| Free tier | Yes. Search grounding is paid tier only | Pricing page |
Google DeepMind published the model card on November 12. It says Hydrogen is adapted from Gemini 4 Carbon. So Hydrogen shares the Carbon feature list and API design, in a smaller and faster model. Google announced Carbon on October 28.
At first, only a group of security teams could use it. Hydrogen was open to everyone on launch day, including the free tier. In the 40 YouTube comments we pulled, the comment with the second-most likes (170) is about this gap.
Gemini 4 Hydrogen pricing: each tier and the gap after December 1
The pricing page gives US dollars per million tokens. The Hydrogen standard price is $1.50 for input and $7.50 for output. Cached input costs $0.075, which is 95% less than the input price. The output price includes thinking tokens.
A note on the page adds one more rule. Every token the model processes is billed, including thinking tokens and the function declarations. So your six function declarations count as input on every turn.
Among the models we compare, Carbon and Argon change the most. Both cost $2 and $10 at the introductory price until November 30. From December 1, they cost $4 and $20, which is double. Gemini 3.8 Flash stays at $0.75 and $3.75 until the end of 2026.
From January 1, 2027, it costs $1.50 and $7.50, the same as Hydrogen. A DevOps.com article on November 16 said Hydrogen costs double what 3.8 Flash costs today. That is true only until the end of this year.
| Model (USD per million tokens) | Input | Output | Cached input | Free tier | Note |
|---|---|---|---|---|---|
| Gemini 4 Hydrogen standard | 1.50 | 7.50 | 0.075 | Yes | Same price for all context sizes |
| Gemini 4 Hydrogen Batch or Flex | 0.75 | 3.75 | 0.0375 | No | Flex latency target 1 to 15 minutes |
| Gemini 4 Hydrogen Priority | 2.70 | 13.50 | — | No | Served before standard and Flex |
| Gemini 4 Carbon or Argon (to Nov 30) | 2.00 | 10.00 | 0.10 | No | Default thinking is medium |
| Gemini 4 Carbon or Argon (from Dec 1) | 4.00 | 20.00 | 0.20 | No | Introductory price ends |
| Gemini 3.8 Flash (2026) | 0.75 | 3.75 | 0.075 | Yes | 1.50 and 7.50 from Jan 1, 2027 |
| Gemini 3.5 Flash-Lite | 0.30 | 2.50 | — | Yes | For classification and routing |
Know the three ways to buy. The Batch API takes requests in one asynchronous batch and costs half. But the documentation says it works only with generateContent, not with the Interactions API. It suits large sets of independent requests sent at once.
Flex, a tier that trades a longer wait for half the price, also costs half and works with the Interactions API through service_tier='flex'. The cost is a latency target of 1 to 15 minutes, and Flex is still in preview. Priority, a tier that puts your requests first in the queue, costs 80% more. It suits support requests that need an answer now.
A multi-step tool loop must wait for each turn before the next turn starts. So Batch does not fit. Flex fits, but each turn can wait several minutes. Use Flex for scheduled checks that run at night.
On the rate limit page, limits depend on spend. Tier 1 needs only a linked billing account and allows $10 of spend every 10 minutes. The daily request count resets at midnight Pacific time, which is 3 p.m. or 4 p.m. in Singapore, depending on daylight saving time.
At our estimated unit cost, $10 per 10 minutes covers about 300 checks. You usually hit the per-minute limit of your data API key first. Our test key allowed 10 requests per minute.
One check: six tool calls across four sources
The task we give the model is one English sentence. "What do people say about Gemini 4 Hydrogen pricing this week? Check web, news, Reddit and YouTube." The model needs data, so we wrote six functions.
Each function maps to one EveryInfra capability. The Reddit API, YouTube API, web search API and Google News API pages list the other capabilities and their parameters. Three of our functions are searches: web/search (web search), google_news/search (Google News search) and reddit/search (Reddit search). The other three are reddit/comments (Reddit comments), youtube/search (YouTube search) and youtube/comments (YouTube comments).
All six use the same endpoint, POST /api/v1/social. The request body has three fields: platform, action and params. The response body has results, count and billing, plus refund when a result is empty.
The check runs in this order. In turn 1, the four searches do not depend on each other, so the model can send them in parallel. In turn 2, the model uses the post and video links from turn 1 to get comments. In turn 3, it writes the report.
With serial calls, the model sends one function call per turn. Six tool calls then need seven model requests. With parallel calls, they need three. Fewer requests mean less context to send again on each request, and that context is most of the cost.
Here is the log of our live calls. The time is when the request left our machine. The cost is the raw billing.charged_usd value from the response body. You can find each request ID in the call records in the console.
| Singapore time (2026-11-19) | Capability | Main parameters | Results | Charged (USD) | Request ID |
|---|---|---|---|---|---|
| 00:23:21 SGT | web/search | "gemini 4 hydrogen pricing", US, English | 10 | 0.001389 | req_b0eb8916926c4a63 |
| 00:24:12 SGT | google_news/search | "gemini 4 hydrogen", past week | 20 | 0.000792 | req_46a6a26a4fe94717 |
| 00:25:14 SGT | reddit/search | "gemini 4 hydrogen", by relevance | 4 | 0.000792 | req_52a46a7e4747419c |
| 00:27:47 SGT | reddit/search | "gemini hydrogen", by newest | 14 | 0.000792 | req_877fe3fa24ee4bcb |
| 00:27:58 SGT | reddit/comments | Launch post on r/singularity | 0 | 0 (refunded) | req_21083fbada684332 |
| 00:28:26 SGT | youtube/search | "gemini 4 hydrogen", by relevance | 10 | 0.000778 | req_86a01257f3cc42d7 |
| 00:28:37 SGT | youtube/comments | The most viewed video | 40 | 0.000556 | req_58f6a18971374aaa |
| 00:30:21 SGT | reddit/comments | Thread on r/GoogleGemini | 0 | 0 (refunded) | req_e0151310d137402b |
| 00:30:32 SGT | web/search | Spain, Spanish | 10 | 0.001389 | req_e0b072de7e274991 |
| 00:31:12 SGT | web/search | Singapore, Simplified Chinese | 10 | 0.001389 | req_25bd028939b348a6 |
The 10 calls cost $0.007877 in total. Both reddit/comments calls returned 0 results, with charged set to false and a refund status of succeeded. But both posts show comments on the Reddit website. In our search at 00:27 SGT, the r/GoogleGemini post showed 12 comments.
We also called youtube/transcript for three videos at 00:33 SGT to get captions, and tried once more at 00:47 SGT. Each call returned 503 (unavailable) and charged nothing. The response body had retry_after: 60 and a tip to try a sample video first.
Handle these two cases in different ways. Mark an empty comment result as "not retrieved this time". Do not write "no one commented" in the report. For a 503, wait for retry_after seconds and try again, or skip the item.

Parallel calls: let the model send several function calls in one turn
The Google function calling guide uses two terms. Parallel function calling means several independent calls in one turn. Compositional function calling means a later call that depends on an earlier result.
Two things decide if the model calls in parallel. The first is whether the functions look independent in their descriptions. The second is whether the system instruction asks for parallel calls.
Our system instruction starts with the sentence "Call independent tools in parallel". The four search functions take only a keyword and enum values, and they do not refer to each other. The two comment functions say "Pass a url from reddit_search" and "Pass a url from youtube_search". So the model knows they must wait for turn 2.
When the model sends parallel calls, your code does not run them in parallel by itself. The agent function below calls EveryInfra one request at a time within a turn. Four searches take tens of seconds in total. To shorten that time, send them at the same time with concurrent.futures.ThreadPoolExecutor. But first check the per-minute limit of your key.
Our test key allows 10 requests per minute. When several processes share it, four requests in the same second can easily get a 429. The model-side savings depend only on the number of turns. Local concurrency changes only how long you wait.
Python code: Gemini 4 Hydrogen API function calling with /api/v1/social
The code has two layers. The tool layer maps each function name to an EveryInfra platform and action. It sends the request, handles 429 and trims the response. We ran this layer on our machine, and it made the 10 calls above. The model layer uses the Interactions API in the Google GenAI SDK.
It puts the six function declarations in tools. When the model returns function_call steps, the code runs them and sends the results back as function_result entries. It adds previous_interaction_id to continue from the last turn. We wrote this layer from the Google function calling guide and the Interactions API overview. We have no Gemini key, so we did not run it.
The first line of the code pins the SDK to version 2. The google-genai page on PyPI says the Interactions API needs version 2.0 or later. In the SDK repository, the notes for version 3.0 change the default API version and the HTTP client. Without a pin, an automatic upgrade to 3.0 can change how the client starts.
# pip install "google-genai>=2,<3" (Interactions API needs SDK 2.0 or later)
import json, os, random, time, urllib.request, urllib.error
from google import genai
EI_URL = "https://api.everyinfra.com/api/v1/social"
EI_KEY = os.environ["EVERYINFRA_API_KEY"]
def fn(name, desc, props, required):
return {"type": "function", "name": name, "description": desc,
"parameters": {"type": "object", "properties": props, "required": required}}
S = {"type": "string"}
TOOLS = [
fn("web_search", "Google-style web results (title, url, snippet). Up to 10.",
{"keyword": S, "country": S, "language": S}, ["keyword"]),
fn("news_search", "Google News articles, newest first. Up to 20.",
{"keyword": S, "time_window": {"type": "string", "enum": ["day", "week", "month"]}}, ["keyword"]),
fn("reddit_search", "Reddit posts from the last month. Use sort=newest for new product names.",
{"keyword": S, "sort": {"type": "string", "enum": ["relevance", "newest", "top"]}}, ["keyword", "sort"]),
fn("reddit_comments", "Comments of one Reddit post. Pass a url from reddit_search.", {"url": S}, ["url"]),
fn("youtube_search", "YouTube videos with views, likes and comment count.",
{"keyword": S, "sort": {"type": "string", "enum": ["relevance", "newest", "most_viewed"]}}, ["keyword", "sort"]),
fn("youtube_comments", "Comments of one YouTube video. Pass a url from youtube_search.", {"url": S}, ["url"]),
]
ROUTE = {"web_search": ("web", "search", 10), "news_search": ("google_news", "search", 20),
"reddit_search": ("reddit", "search", 25), "reddit_comments": ("reddit", "comments", 50),
"youtube_search": ("youtube", "search", 10), "youtube_comments": ("youtube", "comments", 40)}
KEEP = {"web_search": ["rank", "title", "url", "text", "published_at"],
"news_search": ["title", "url", "source", "published_at"],
"reddit_search": ["url", "title", "text", "community", "like_count", "comment_count", "posted_at"],
"reddit_comments": ["text", "like_count", "posted_at"],
"youtube_search": ["url", "title", "view_count", "like_count", "comment_count", "posted_at"],
"youtube_comments": ["text", "like_count", "posted_at"]}
def call_everyinfra(platform, action, params, tries=8):
body = json.dumps({"platform": platform, "action": action, "params": params}).encode()
for attempt in range(tries):
req = urllib.request.Request(EI_URL, data=body, method="POST", headers={
"Authorization": f"Bearer {EI_KEY}", "Content-Type": "application/json"})
try:
with urllib.request.urlopen(req, timeout=120) as r:
return r.status, json.loads(r.read())
except urllib.error.HTTPError as e:
data = json.loads(e.read() or b"{}")
err = data.get("error") or {}
if e.code == 429 and attempt < tries - 1: # 429 is not charged; retry_after sits inside "error"
time.sleep(int(err.get("retry_after") or 10) + random.uniform(1, 6))
continue
return e.code, data
return 0, {}
def run_tool(name, args):
platform, action, limit = ROUTE[name]
status, data = call_everyinfra(platform, action, {"limit": limit, **args})
if status != 200: # give the model the error text, not an exception
err = data.get("error") or {}
return {"error": status, "code": err.get("code"), "message": err.get("message")}
rows = [{k: r.get(k) for k in KEEP[name] if r.get(k) not in (None, "", [])} for r in data.get("results") or []]
for r in rows:
if isinstance(r.get("text"), str) and len(r["text"]) > 280:
r["text"] = r["text"][:280] + "…"
return {"count": len(rows), "rows": rows}
SYS = "Call independent tools in parallel. Use at most 8 tool calls. Then write a short report with links."
def agent(task, model="gemini-4-hydrogen", max_turns=6):
client = genai.Client() # reads GEMINI_API_KEY
cfg = {"thinking_level": "low"}
it = client.interactions.create(model=model, input=task, tools=TOOLS,
system_instruction=SYS, generation_config=cfg)
for _ in range(max_turns):
calls = [s for s in it.steps if s.type == "function_call"]
if not calls:
break
results = [{"type": "function_result", "name": c.name, "call_id": c.id,
"result": [{"type": "text", "text": json.dumps(run_tool(c.name, c.arguments), ensure_ascii=False)}]}
for c in calls]
# tools and system_instruction apply to one interaction only: send them again every turn
it = client.interactions.create(model=model, input=results, tools=TOOLS, system_instruction=SYS,
generation_config=cfg, previous_interaction_id=it.id)
print("usage:", it.usage)
return it.output_text
if __name__ == "__main__":
print(agent("What do people say about Gemini 4 Hydrogen pricing this week? Check web, news, Reddit and YouTube."))Four points in this code come from our own mistakes or from the documentation. First, the retry_after value for a 429 is inside the error object of the response body. On our first run, the code read it from the top level.
It waited the default time and got 429 again. After the fix, the code reads error.retry_after and adds 1 to 6 seconds of random jitter. When several processes share one key, the jitter stops them from retrying in the same second.
Second, tools and system_instruction in the Interactions API apply to one request only. The previous_interaction_id field carries the conversation, not the configuration. So send both again on every turn.
Third, the model can send several function_call steps in one turn. Return each result with its matching call_id. The order can differ from the call order.
Fourth, when a call fails, return the error code and message to the model as the function result. The Hydrogen launch post says the model can change course when a tool fails. It can do that only when it sees the error. If your code raises an exception, the model cannot change anything.
The Google guide suggests 10 to 20 tools at most per request, with strong types and enums where possible. If the declarations are too complex or too deeply nested, the API can return 400 INVALID_ARGUMENT in any mode. We made the sort order and the time window enums.
The reddit_search description says "Use sort=newest for new product names." That rule comes from the Reddit test below. The six declarations are 1,810 characters, about 452 tokens. With the system instruction and the task, the fixed base of every model request is about 502 tokens.
You can test the data API before you have a Gemini key. One curl command shows the response shape. The parameters match the function declarations. Get your key from the quickstart and keep it in an environment variable, not in a code file.
curl -s https://api.everyinfra.com/api/v1/social \
-H "Authorization: Bearer $EVERYINFRA_API_KEY" \
-H "Content-Type: application/json" \
-d '{"platform":"reddit","action":"search","params":{"keyword":"gemini hydrogen","sort":"newest","limit":25}}'Function count: six specific functions or one general function
Another design gives the model one general function. Its parameters are platform, action and params, and the model fills them in. The declaration is shorter, and one function can call all 576 available EveryInfra capabilities. The cost is that the model must know the name and parameters of each capability. On the first call, it often looks up the catalog first, which adds a turn.
When it fills a parameter wrong, it gets a 422 and must try again. We chose six specific functions because the check is fixed. Enums lock the sort order and the time window, which are easy to get wrong. The model has almost no room for mistakes.
Six specific functions take about 452 tokens, and one general function takes one or two hundred. The parameters and responses are the same size in both designs. If the task changes often, use a general function or a remote MCP server. If the task is fixed and runs hundreds of times a day, specific functions are easier to maintain.
Response size: tokens before and after trimming
Input is most of the model cost, and tool responses are most of the input. We serialized each real response and estimated tokens at 4 characters per token. We then compared that size with the trimmed size. The trimmed version keeps only the KEEP fields and cuts body text to 280 characters.
The Google token guide says one token is about 4 characters for Gemini models. Chinese text, emoji and links do not follow this ratio. So treat the numbers below as orders of magnitude, with an error of about 20%.
| Response (estimated tokens) | Full | Trimmed | Cut |
|---|---|---|---|
web/search US English, 10 results | 1,062 | 847 | 20.2% |
google_news/search, 20 results | 2,970 | 1,305 | 56.1% |
reddit/search by newest, 14 results | 5,302 | 1,919 | 63.8% |
reddit/search by relevance, 4 results | 8,173 | 622 | 92.4% |
youtube/search, 10 results | 2,171 | 650 | 70.1% |
youtube/comments, 40 results | 3,883 | 1,620 | 58.3% |
reddit/comments, empty | 240 | 11 | — |
| Six calls of one check, total | 15,628 | 6,352 | 59.4% |
The Reddit search by relevance returned only 4 posts, but the full response was 8,173 tokens. Some of those posts were long health threads and investment analyses with thousands of words of body text. Trimming works best on this kind of response. It keeps the title, the community, the likes, the comment count and the first 280 characters. That is enough for the model to judge whether a post is about Hydrogen.
Web search results contain only titles, links and snippets, so trimming removes a few fields and saves 20%. Our method is simple. Save the full response to disk. Give the model only the trimmed version. When the report must quote a source, read it from disk.
Our article on Claude Code subagents for TikTok brand accounts uses the same idea. There, raw data stays in each subagent, and the main session gets only summaries. Here, the trimming happens at the level of function results.
Fix one more field before you give it to the model. In youtube/comments, posted_at is a relative time such as "5 days ago", not a date. The model cannot tell which day it is relative to, so the report can get dates wrong. Convert it to a date in the tool layer, based on the time of the call. Or give the model only the like count and the text, and use the video date instead.
Estimated cost of 1,000 tool calls: model tokens plus data calls
The cost has two parts. The data calls use the prices in the EveryInfra catalog, so this part is exact. The list prices for the six tools of one check add up to $0.005099. For 1,000 tool calls, which is about 167 checks, that is $0.85.
In our test, the one reddit/comments call in the check was empty and refunded, so the check really cost $0.004307. We use the list price, so our number is an upper limit. The data cost does not depend on the model. See the pricing page for each capability.
| Capability | List price per call (USD) | Per 1,000 calls (USD) | Calls per check |
|---|---|---|---|
web/search | 0.001389 | 1.389 | 1 |
google_news/search | 0.000792 | 0.792 | 1 |
reddit/search | 0.000792 | 0.792 | 1 |
reddit/comments | 0.000792 | 0.792 | 1 |
youtube/search | 0.000778 | 0.778 | 1 |
youtube/comments | 0.000556 | 0.556 | 1 |
| One check, total | 0.005099 | — | 6 |
The prices come from the EveryInfra capability catalog as read at 00:14 SGT on 2026-11-19. Empty results are refunded, so the real charge can only be lower.
Web search is the most expensive of the six. It is 27% of the data cost of one check. The two comment calls together cost $0.001348, which is 26%. The refund made the real charge $0.000792 lower than the list price. That is exactly the list price of one reddit/comments call.
We did not measure the model cost. We estimated it with one formula. For each model request, multiply the input tokens by the input price. The input is the base plus all earlier outputs and tool responses. Add the output tokens times the output price. Bill the cached part at the cached price.
We cannot measure output tokens. With thinking_level=low, we assume 500 output tokens per tool turn, for thinking and call arguments. We assume 1,500 tokens for the final report.
The cache follows the rules on the Google caching page. A request is cached only if its input is at least 4,096 tokens. In an agent loop, the full previous request is a cache hit only when the new request adds at least 2,050 tokens. If it adds less, the last 2,050 tokens are processed again at the standard price.
| 1,000 tool calls (USD; model cost estimated at 4 characters per token and 500 output tokens per tool turn) | Model | Data calls | Total |
|---|---|---|---|
| Carbon December price, serial, full, no cache | 58.59 | 0.85 | 59.44 |
| Hydrogen, serial, full, no cache | 21.97 | 0.85 | 22.82 |
| Hydrogen, serial, full, cache | 12.08 | 0.85 | 12.93 |
| Hydrogen, serial, trimmed, no cache | 14.69 | 0.85 | 15.54 |
| Hydrogen, parallel, trimmed, no cache | 6.64 | 0.85 | 7.49 |
| Hydrogen, parallel, trimmed, cache | 5.29 | 0.85 | 6.14 |
| Carbon November price, parallel, trimmed, cache | 7.05 | 0.85 | 7.90 |
| Carbon December price, parallel, trimmed, cache | 14.09 | 0.85 | 14.94 |
| Gemini 3.8 Flash 2026 price, parallel, trimmed, cache | 2.68 | 0.85 | 3.53 |
| Hydrogen Flex, parallel, trimmed, cache | 2.64 | 0.85 | 3.49 |
| Step on Hydrogen | Model cost per 1,000 tool calls | Change |
|---|---|---|
| Serial, full responses, no cache | $21.97 | Start |
| Trim responses | $14.69 | −33% |
| Add parallel calls | $6.64 | −55% |
| Add implicit cache | $5.29 | −20% |
First, the method changes the cost by more than three times on the same model. Hydrogen costs $22.82 with serial calls and full responses, and $6.14 with parallel calls, trimming and cache.
Parallel calls give the largest part of the $16.68 saving. With serial calls, request 7 carries all six earlier responses, so its input alone is 19,130 tokens. With parallel calls, the last request is 7,854 tokens.
Second, the data calls are a small part of the total cost. They are 13.8% of the cheapest method and only 3.7% of the serial method.
Third, from December 1, Carbon costs 2.4 times as much as Hydrogen for the same method. Before November 30, the gap is only 29%. If you run checks on Carbon now, compare quality on Hydrogen before the end of the month.
Suppose you run 100 checks a day with six tools each. That is 18,000 tool calls a month. Hydrogen with parallel calls, trimming and cache costs about $110 a month, and the data calls are about $15 of it. The same work with serial calls and full responses costs about $411.
Carbon at its December price with the optimized method costs about $269. Flex for night batches costs about $63. The data cost is small in dollars. The model cost can differ by hundreds of dollars. So the method and the model deserve more of your time than the unit price of each data source.
Gemini 3.8 Flash looks the cheapest, but its price rises to the Hydrogen price on January 1, 2027. Flex at $3.49 is the cheapest way to run Hydrogen. Each turn can wait 1 to 15 minutes, so use it only for night jobs.
The Google pricing page says function declarations are billed as input. That cost is already in the table. Of the 502-token base of each request, 452 tokens are function declarations. The seven serial requests carry about 3,164 tokens of declarations, which is 4.8% of the total input of about 65,000 tokens.
The three parallel requests carry about 1,356 tokens of declarations, which is 9.6% of 14,079. The shorter the trimmed responses, the larger the share of the declarations. Then short declarations, and only the tools the task needs, save a larger share.
Output tokens per turn: the sensitivity test
The least certain number in the estimate is 500 output tokens per tool turn. The Hydrogen thinking level changes the number of thinking tokens a lot. The Google thinking page says thinking tokens are billed at the output price, and high is the default level. If you do not set low in your code, as we do, the output per turn can be several times our assumption. We ran the bill again for 250 to 4,000 output tokens per turn, with parallel calls, trimming and cache.
| Output tokens per turn | Hydrogen | Carbon December price | Gemini 3.8 Flash 2026 price |
|---|---|---|---|
| 250 | 5.87 | 14.23 | 3.38 |
| 500 | 6.14 | 14.94 | 3.53 |
| 1,000 | 7.64 | 18.96 | 4.28 |
| 2,000 | 10.65 | 26.99 | 5.80 |
| 4,000 | 16.68 | 43.06 | 8.82 |
All values are USD for 1,000 tool calls, including $0.85 of data calls.
Each extra 1,000 thinking tokens per turn adds about $3 to the Hydrogen total. A change from serial to parallel calls saves about $8. So make the calls parallel and trim the responses first.
Then tune the thinking level. Before you go live, measure for one week. Read total_thought_tokens and total_output_tokens from interaction.usage, and replace our 500 with your real value.
Thinking levels: is low enough?
Our code uses thinking_level: low to save money. Low has a cost. The OpenRouter model page quotes Artificial Analysis results for all four levels. These are third-party numbers. Google does not publish scores for each level.
On AutomationBench, the score goes from 60.5 at low to 72.0 at medium, 74.4 at high and 76.1 at xhigh. On Terminal-Bench 4.0, the gap is larger: 6.6 at low, 29.3 at medium, 54.0 at high and 53.5 at xhigh. The intelligence index goes from 26.9 at low to 50.8 at high.
| Thinking level | AutomationBench | Terminal-Bench 4.0 | Intelligence index |
|---|---|---|---|
| low | 60.5 | 6.6 | 26.9 |
| medium | 72.0 | 29.3 | 41.2 |
| high (default) | 74.4 | 54.0 | 50.8 |
| xhigh | 76.1 | 53.5 | 53.9 |
Our check is simple routing. The function parameters are keywords and enums. The model decides which tools to call and which comments to get in turn 2. This kind of task is closer to AutomationBench than to Terminal-Bench, and there low is about 14 points below high. Use medium when the model must read results, find the off-topic posts and choose new keywords.
Medium is the default for Carbon and Argon. The Hydrogen default is high. The Google thinking page adds that the level is a ceiling for thinking. On simple requests, the model does not always use the full budget.
Gemini 4 Hydrogen pricing and Search grounding: why connect your own search
The Gemini API includes grounding with Google Search, and it is the easiest option. You add google_search to tools, and the model decides when to search. But the pricing page is clear. For Hydrogen, Search grounding is on the paid tier only.
All Gemini 3 and later models share 5,000 free requests per month. After that, it costs $14 per 1,000 requests, with a cap of 1,500 requests per day. One customer request can trigger several searches, and each search is billed.
| Item | Google Search grounding | EveryInfra `web/search` |
|---|---|---|
| Free quota | 5,000 requests per month, shared by Gemini 3 and later | None |
| Price after the quota | $14 per 1,000 requests | $1.389 per 1,000 calls |
| Daily cap | 1,500 requests | Per-minute key limit |
| Free tier of Gemini | Not available for Hydrogen | Works with any model |
| What you get | Citations in the model answer | Raw ranks 1 to 10 with title, link and snippet |
EveryInfra web/search costs $0.001389 per call, so 1,000 calls cost $1.389. Grounding after the free quota costs 10.1 times as much. Price is not the only difference. With grounding, the model reads the results and gives you citations.
You do not get the raw ranked list. With web/search, you get the title, link and snippet for ranks 1 to 10. You can save them, compare them and query by country and language.
At 00:30 and 00:31 SGT, we asked the same pricing question in Spanish for Spain ("gemini 4 hydrogen precio api") and in Simplified Chinese for Singapore. The top Spanish result was the Spanish OpenRouter pricing page, and rank 2 was the Spanish DataCamp guide. The top Chinese result was the AI Studio pricing page. Rank 3 was the Google Cloud pricing page in Chinese.
Rank 5 was an X post about the Carbon and Argon price rise on December 1. People who search in different languages see very different results. For checks across markets, query each market on its own.
Keywords and sort order: four Reddit results, all off topic
At 00:25 SGT, we searched Reddit for "gemini 4 hydrogen" by relevance. The search returned 4 posts, and all 4 were about other things. They came from the CLNE, Joby, BrawlStarsEsports and SIBO communities. The topics were a hydrogen fuel company, a hydrogen aircraft, an esports player called Gemini and a hydrogen breath test for a gut condition.
At 00:27 SGT, we searched for "gemini hydrogen" by newest. The search returned 14 posts, and 6 were about the model. Those 6 posts had 16 likes and 16 comments in total. Our rule was simple: a post counts when its title contains "hydrogen" and its title or community name contains "gemini".

| Search (SGT) | Keyword | Sort | Posts | About the model | Likes and comments on those posts |
|---|---|---|---|---|---|
| 00:25:14 SGT | gemini 4 hydrogen | relevance | 4 | 0 | 0 and 0 |
| 00:27:47 SGT | gemini hydrogen | newest | 14 | 6 | 16 and 16 |
One possible reason, which we did not test, is this. The new model name overlaps with existing words. Relevance sort puts old, long posts with strong matches first, and new posts have no votes yet.
The model sees only 4 off-topic results. It can then write "there is no discussion on Reddit", and that is wrong. Our function description says "Use sort=newest for new product names." We also made sort a required parameter, so the model must choose a sort order every time.
In the newest list, our rule left out 8 of the 14 posts. Two were about Gemini but not Hydrogen. "Long chats stops responding with Argon" on r/GeminiAI had 7 likes. "Antigravity turned one today, and the birthday gift was a full usage reset" had 22 likes, the most of all 14 posts.
The other six were a French tech podcast and a Spanish post about a coding agent. There were also two update notes from third-party AI tools, a news repost about Gemini Tasks and a thread about developer credits. Their titles mention only Gemini 4 or Gemini.
So the newest sort still gives more than half noise. But that noise is other Gemini news, and the model can sort it out from the titles. With relevance sort, the noise was hydrogen fuel and esports. The model could not even tell whether anyone discussed the topic.
YouTube did not have this problem. The 10 videos from youtube/search by relevance were all about Hydrogen, with 330,691 views in total. The most viewed was "Gemini 4 Hydrogen Just Dropped" from launch day, November 12, with 193,622 views and 268 comments. Next was a full test from November 13 with 97,332 views and 316 comments.
In the news results, 11 of 20 articles came out on November 12. By November 17, there was only one.
| Date (UTC) | Articles | Examples |
|---|---|---|
| 2026-11-12 | 11 | Three blog.google posts, Ars Technica, The Decoder, 9to5Google, SiliconANGLE, VentureBeat |
| 2026-11-13 | 4 | GitHub changelog (Copilot), Mashable, a Medium comparison with Claude Haiku 5.5 |
| 2026-11-15 | 1 | Tom's Guide on five things to do for free |
| 2026-11-16 | 3 | DevOps.com, TechRadar, AI Insider |
| 2026-11-17 | 1 | Google for Developers blog on robotics |
Only 3 of the 20 titles mention price. VentureBeat calls Hydrogen a pricier Flash successor. The shattered.io title gives the $1.50 input price. Tom's Guide says it is free.
The other 17 titles are about speed, benchmark scores, the default model in Search and integrations. So news gives little direct evidence about what people think of the price. The price discussion is mostly in the web pricing pages and in community comments.
What one check gives the model
After trimming, the six real responses give the model this data. In the top 10 web results, rank 1 is the OpenRouter pricing and benchmark page. Rank 3 is the Artificial Analysis page. Rank 4 is an article about the $1.50 and $7.50 prices and the cost per task. Rank 5 is the launch post on r/singularity.
There are 20 news articles, and 11 come from launch day. The sources include blog.google, Ars Technica, The Decoder, 9to5Google, SiliconANGLE, Search Engine Journal and the GitHub changelog. Reddit by newest gives 14 posts, and 6 are about the model. Their titles say it is slow and ask if it still hallucinates.
Others report a doubled context in Antigravity and folders read as zip files. The last two mention a new benchmark and API usage. YouTube gives 10 videos and 40 comments from the most viewed video.
Two hard facts in this data make a simple acceptance test. Reddit by newest has 6 posts about the model. Three YouTube comments mention usage or limits. If your agent writes "no discussion on Reddit", or says nothing about usage, check the keywords, sort order and trimming. You can trace both facts to the raw responses by request ID.
The Spanish top 5 included the LiteLLM pricing post. The Singapore Chinese top 5 included the AI Studio pricing page and an X post about the December price rise.
For checks across language markets, fix country and language for each market in the code. Do not leave that choice to the model in the moment.
Use a remote MCP server instead of your own functions
The Interactions API can connect to a remote MCP server directly. Then you do not write function declarations or a tool layer. If you do not want to write the loop, Managed Agents can also connect to a remote MCP server. See Gemini Managed Agents with a remote MCP server for brand monitoring. The function calling guide lists the limits. Only the Streamable HTTP transport works, not the older SSE transport.
The server name must not contain "-", so use underscores. The configuration can include headers for authentication and allowed_tools to limit which tools the model can call. The EveryInfra MCP server uses Streamable HTTP and follows the transport rules in the MCP specification version 2025-11-25.
import os
from google import genai
client = genai.Client()
it = client.interactions.create(
model="gemini-4-hydrogen",
input="What do people say about Gemini 4 Hydrogen pricing this week? Check web, news, Reddit and YouTube.",
tools=[{
"type": "mcp_server",
"name": "everyinfra", # no "-" in the server name
"url": "https://api.everyinfra.com/mcp",
"headers": {"Authorization": f"Bearer {os.environ['EVERYINFRA_API_KEY']}"},
"allowed_tools": ["everyinfra_call_api", "everyinfra_get_job"],
}],
generation_config={"thinking_level": "medium"},
)
print(it.output_text)The cost of MCP is the size of the tool descriptions. At 00:29 SGT, we sent tools/list to the EveryInfra MCP server. It returned 12 tools in 16,760 characters, about 4,190 tokens. That is over nine times the size of our six function declarations, about 452 tokens.
With only everyinfra_call_api and everyinfra_get_job allowed, the size drops to 2,620 characters, about 655 tokens. With MCP, the model must choose platform and action from the catalog by itself. On the first call, it can look up the catalog first, which adds a turn. Your own functions fix the capabilities in advance, so the model has one less step.

| Method | Tool description size | Turns for one check | Who picks the capability |
|---|---|---|---|
| Six own functions | 1,810 characters, about 452 tokens | 3 with parallel calls | Your code |
| Remote MCP, all 12 tools | 16,760 characters, about 4,190 tokens | 3 or 4, with a catalog lookup | The model |
| Remote MCP, two allowed tools | 2,620 characters, about 655 tokens | 3 or 4, with a catalog lookup | The model |
Our advice: use your own functions for fixed, scheduled checks. The capabilities stay fixed, the declarations stay short and every turn costs less. Use MCP for open questions, so the model can search the 576 available capabilities. The EveryInfra charge is the same either way. Only the model tokens differ.
What people complain about in videos and comments
At 00:28 SGT, we searched YouTube by relevance. All 10 videos were about Hydrogen, with 330,691 views in total. The table keeps the order of the API response.
| Rank | Video | Date (UTC) | Views | Comments |
|---|---|---|---|---|
| 1 | FREE Gemini 4 Hydrogen vs $100 Claude Fable 5.2 | 2026-11-16 | 11,362 | 157 |
| 2 | Gemini 4 Hydrogen + Antigravity is WILD | 2026-11-17 | 5,524 | 2 |
| 3 | Gemini 4 Hydrogen Just Dropped (Personally Tested) | 2026-11-12 | 193,622 | 268 |
| 4 | NEW Gemini 4 Hydrogen vs. Gemini 4 Argon | 2026-11-17 | 3,704 | 5 |
| 5 | The NEW Gemini 4 Hydrogen is INSANE | 2026-11-12 | 9,171 | 2 |
| 6 | Gemini 4 Hydrogen Is the BEST Flash Model Yet – Full Test! | 2026-11-13 | 97,332 | 316 |
| 7 | Gemini 4 Hydrogen: Google's New General-Purpose Model | 2026-11-16 | 361 | 0 |
| 8 | 13 Gemini 4 Hydrogen Builds: Is It Better Than Opus? | 2026-11-17 | 457 | 0 |
| 9 | Google Just Released Gemini 4 Hydrogen! | 2026-11-15 | 5,958 | 1 |
| 10 | Gemini 4 Hydrogen vs Claude Opus 5.5: 10-Round SHOWDOWN | 2026-11-12 | 3,200 | 2 |
Two videos have most of the views. Videos 3 and 6 have 290,954 views together, which is 88.0% of the total. The other eight have fewer than 40,000 views together.
Relevance sort did not put the most viewed video first. Rank 1 has only 11,362 views. A check that reads only the top three misses video 6, with 97,332 views and 316 comments. Four of the 10 titles compare Hydrogen with another model: Claude Fable 5.2, Argon or Opus. No title mentions the API or function calling.
We tried to get captions for the top three videos, but all three youtube/transcript calls returned 503. So we report only what the comments say, not what the videos show.
We pulled 40 comments from video 3, the most viewed. By keyword count, 3 mention usage or limits, 3 mention price and 5 discuss the model names. The top comment, with 178 likes, is a one-line joke about the names, with the formula H2O. The second, with 170 likes, says Carbon was announced weeks ago and is still out of reach, while everyone got Hydrogen at once.
The third, with 86 likes, is glad to have a model people can use today, not only read about. A comment with 11 likes under the same video says Argon gives about five prompts on AI Pro before the limit. A comment with 14 likes says Carbon is already on the API. Two of the top three are about access. None of the eight comments with the most likes is about price.
| Likes | What the comment says (6 selected) | Topic |
|---|---|---|
| 178 | A joke about H2O and the names | Names |
| 170 | Carbon announced weeks ago and still out of reach, Hydrogen open to all | Access |
| 86 | Finally a model people can use today | Access |
| 31 | Likes the new model names | Names |
| 14 | Carbon is already on the API | Access |
| 11 | Argon gives about five prompts on AI Pro | Usage |
These are 40 youtube/comments results from 00:28:37 SGT, request req_58f6a18971374aaa. We do not show commenter names.
On Reddit, "Gemini 4 Hydrogen is super slow" on r/GoogleGeminiAI had 0 votes and 3 comments when we found it. "Gemini Hydrogen still hallucinating?" on r/GoogleGemini had 12 votes and 12 comments. We did not get the comments of either post. The reddit/comments call for the second post returned 0 results. So we can say only that people ask about speed and fabrication. We cannot say what most replies think.
Moving from 3.8 Flash to Hydrogen: what to change
Do you already run a tool agent on Gemini 3.8 Flash? Then read the migration list on the "What's new" page. Some items affect the code and the bill above. First, change the model code from gemini-3.8-flash to gemini-4-hydrogen.
Second, the context is now one shared window of 1,048,576 tokens for input, thinking and output. Gemini 3.8 Flash has separate limits: one million for input and 64K for output. Remove any small hard-coded max_output_tokens value, or raise it to 65,536.
Third, the default thinking level changes from medium to high, and xhigh is new. A request with minimal now fails. If your 3.8 Flash code sets minimal, change it first. Otherwise every request fails.
| Setting | Gemini 3.8 Flash | Gemini 4 Hydrogen |
|---|---|---|
| Model code | gemini-3.8-flash | gemini-4-hydrogen |
| Context | 1M input and 64K output, separate | 1,048,576 shared by input, thinking and output |
| Default thinking | medium | high, plus the new xhigh |
| minimal | Accepted | Returns an error |
| Explicit caching | Supported | Not supported, implicit only |
| Search grounding on the free tier | Yes | No |
| Price in 2026 | $0.75 and $3.75 | $1.50 and $7.50 |
The fourth item is easy to miss. Hydrogen does not support explicit caching. The 3.8 Flash model page lists context caching as supported. If you cache a long fixed system instruction or document with cachedContents on 3.8 Flash, that code stops working on Hydrogen.
Only implicit caching remains. Implicit caching needs a prefix of at least 4,096 tokens. In an agent loop, it needs at least 2,050 new tokens per turn for a full hit.
In our check, the first two requests are under 4,096 tokens. Only the third request gets a cache hit. That is why the cache saves only about 20%. A longer fixed system instruction gets the cache to work sooner, but it also makes every turn larger. Calculate both effects together.
The fifth item is about cost. Gemini 3.8 Flash can use Search grounding on the free tier, and Hydrogen cannot. A free-tier project that searches through grounding must upgrade to the paid tier or connect its own search functions, as this article does.
Measure these numbers before you go live
Three numbers in our cost model are estimates, and you should measure all three. The first is the token count. We estimated 4 characters per token.
After launch, read the usage of each request. The Interactions API gives total_input_tokens, total_output_tokens, total_thought_tokens and total_cached_tokens. One week of data is enough to replace our estimate.
The second number is the output per turn, the column in the sensitivity table. It changes when you change the thinking level. The third is the real number of tool calls. We assume six per check.
The model can call more, or fewer when turn 1 gives enough data. Our system instruction says "at most 8 tool calls". Also set max_turns in the code, so a check that goes wrong cannot loop forever.
Measure two numbers on the data side too. The first is the per-minute request limit of each key. A key shared by several processes gets a 429 easily. In production, give each agent its own key, or add a per-minute rate limiter to the tool layer. The second is the share of empty results.
In this test, both reddit/comments calls were empty. If the empty share is high after launch, change the parameters. Or make the report template list the items it could not get. The console call records show the status code and charge for each request, by capability. Use them when you reconcile costs.
Budget limits: stop one bad check from spending a day of budget
A multi-step tool loop can go wrong. The model does not like a result, so it searches again and again with new keywords. One check can then make dozens of tool calls.
Use three limits together. On the model side, the Google billing page says each billing tier has an account spend cap, and the Tier 1 cap is $250. The rate limit page says Tier 1 can spend $10 per 10 minutes at most.
In the code, max_turns limits the turns. The system instruction says "at most 8 tool calls", and the tool layer counts again. Above the limit, it stops and returns "limit reached" as the result. On the data side, EveryInfra uses a prepaid balance. When the balance runs out, requests are refused, so you cannot overspend.
By our estimate, a normal check costs about $0.032 in model tokens and about $0.005 in data calls. A check that goes wrong can make 30 tool calls with serial calls and full responses. Then the input of one request can exceed 100,000 tokens, and one check can cost several dollars.
Log the usage of each check. Send an alert when a check costs more than three times the average. You find the problem sooner than at month end.
Errors and how to handle them
Our test hit four kinds of errors, and each needs a different response. A 429 means the key reached its per-minute limit, which happens easily when several processes share it. A 429 costs nothing. The response gives the wait time in error.retry_after. Wait that long and add random jitter.
An empty result returns 200, with count set to 0, billing.charged set to false and refund.status set to succeeded. The money comes back by itself. But an empty result does not always mean there is no data. Check other signals, such as a search result that shows 12 comments on that post.
A 503 returns error.code set to unavailable and retryable set to true, with retry_after: 60. It costs nothing. Wait one minute and try again, or say in the report that this item was not retrieved.
A 400 from the Gemini side means a function declaration is too complex. The error is 400 INVALID_ARGUMENT. Make the nesting shallower and remove optional fields.
| Error | Charged | What goes to the model | What the code does |
|---|---|---|---|
| EveryInfra 429 | No | Nothing, the tool layer retries | Read error.retry_after, add 1 to 6 seconds of jitter |
200 with count 0 | Refunded | {"count": 0} and a note "not retrieved" | The report does not say "no discussion" |
| EveryInfra 503 unavailable | No | The error code and message | Wait retry_after seconds and retry, or skip |
| Gemini 400 INVALID_ARGUMENT | — | — | Simplify declarations, with less nesting and fewer enums |
| Gemini free tier daily limit | — | — | Resets at midnight Pacific time, or move to the paid tier |
The Hydrogen launch post says the model can change course when a tool fails. That works only when you send the failure back to the model as it is. Our run_tool returns the error code and message when the status is not 200. When the model sees unavailable, it can call youtube/comments instead of the captions. Or it can say in the report that this item is missing.
Where this method fits
This method fits fixed checks: the same question and the same sources, every day. One example is a developer tools team. Each morning, it wants to know how people review a competitor's new release in its first week. It checks the web, the news, Reddit and YouTube. Another example is a cross-border store.
It wants search results and video comments for one product category in the US, Spain and Mexico, one market at a time. The question is the same every day. The model reads the results, finds what changed and writes a few paragraphs. By our estimate, one check costs about $0.03 in model tokens.
It fits less well when the task needs deep judgment. For example, you sort hundreds of comments into product defect types and rate how severe each type is. Or you read long analyses and write a conclusion with a clear position.
Then the thinking level must be high or xhigh, and the output per turn reaches thousands of tokens. By the sensitivity table, the Hydrogen total reaches $10 to $17. It still costs less than Carbon, but the cost is no longer a few cents per check.
FAQ
What is the Gemini 4 Hydrogen pricing?
Input costs $1.50 and output costs $7.50 per million tokens. Output includes thinking tokens. Cached input costs $0.075. The price is the same across the full one-million-token context, with no extra charge for long prompts.
Batch and Flex cost $0.75 and $3.75. Priority costs $2.70 and $13.50. The numbers come from the AI Studio pricing page.
Gemini 4 Hydrogen vs 3.8 Flash: should I switch?
In 2026, Gemini 3.8 Flash costs half the Hydrogen price. From January 1, 2027, both cost the same. Google names Hydrogen as the upgrade from 3.8 Flash. The launch post says it is 2.5 times faster, and its Terminal-Bench score rises from 18.2% to 57%.
When you migrate, note that the default thinking level changes from medium to high, minimal is no longer accepted and the output limit becomes 65,536. See the migration list on the What's new page.
Gemini 4 Hydrogen vs Argon vs Carbon: which should I use?
The Google model guide gives this advice. Use Hydrogen for everyday coding, tool agents and parallel subtasks. Use Carbon for hard architecture, debugging, science and security checks. Use Argon for long reasoning with fewer tokens than Carbon.
From December 1, Carbon and Argon cost 2.67 times the Hydrogen unit price. With our check method, the total is 2.4 times. See Choosing a model.
Can the Gemini 4 Hydrogen API use tool calls on the free tier?
Yes. The pricing page says Hydrogen is on the free tier, and function calling costs nothing extra. But Google Search grounding is paid tier only, and Google can use free-tier inputs to improve its products.
A r/GeminiFeedback post asks how API usage differs from chat modes. The two quotas are counted apart. See the Reddit thread.
What do I do when the Gemini API returns 400?
With function calling, the most common cause is a declaration that is too complex. The API compiles declarations into a state machine that limits generation. Deep nesting or too many enum values cause 400 INVALID_ARGUMENT, and the error names the field.
Remove optional fields, make the nesting shallower and keep 10 to 20 tools at most. See the limits section of the function calling guide.
Is Gemini 4 Hydrogen really slow?
A r/GoogleGeminiAI post says it is very slow. It had 3 comments when we found it. We did not measure latency on the API. In public data, the launch post says it is 2.5 times faster than 3.8 Flash.
A lower thinking level, such as low or medium instead of the default high, uses fewer thinking tokens. Responses are then usually faster. Measure this with your own requests before you go live. See the Reddit post.
Does Gemini 4 Hydrogen still make things up?
The launch post says it makes over five times fewer fabricated claims than 3.8 Flash. 9to5Google quoted an honesty score of 96.7%, and the current launch post says 94%. A r/GoogleGemini post still asks why it makes things up.
In tool loops, ask for links in the report and mark empty results as "not retrieved". This reduces reports that turn missing data into conclusions. See the Reddit post.
References
- Introducing Gemini 4 Hydrogen for Agentic Workflows, blog.google, published 2026-11-12, updated 2026-11-16, https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-hydrogen/
- Gemini 4 Hydrogen model page, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/models/gemini-4-hydrogen
- What's new in Gemini 4 Hydrogen, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/whats-new-gemini-4-hydrogen
- Gemini Developer API pricing, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/pricing
- Function calling, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/function-calling
- Interactions API overview, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/interactions-overview
- Understand and count tokens, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/tokens
- Rate limits, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/rate-limits
- Context caching, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/caching
- Thinking, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/thinking
- Choosing a model, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/choosing-a-model
- Grounding with Google Search, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/google-search
- Batch API, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/batch-api
- Flex inference, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/flex-inference
- Priority inference, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/priority-inference
- Structured outputs, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/structured-output
- URL context, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/url-context
- Text generation, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/text-generation
- Long decode, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/long-decode
- Gemini 4 Carbon model page, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/models/gemini-4-carbon
- What's new in Gemini 4 Carbon, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/whats-new-gemini-4-carbon
- Gemini 3.8 Flash model page, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/models/gemini-3.8-flash
- Models, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/models
- Billing, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/billing
- Computer use, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/computer-use
- Gemini 4 Hydrogen model card, Google DeepMind, 2026-11-12, https://deepmind.google/models/model-cards/gemini-4-hydrogen/
- Introducing Gemini 4 Carbon, blog.google, 2026-10-28, https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-carbon/
- Gemini 4 Hydrogen in Google Antigravity, Antigravity blog, read 2026-11-19, https://antigravity.google/blog/gemini-4-hydrogen-in-google-antigravity/
- Gemini 4 Hydrogen in GitHub Copilot, GitHub changelog, 2026-11-13, https://github.blog/changelog/2026-11-13-gemini-4-hydrogen-in-github-copilot/
- google-genai, PyPI, read 2026-11-19, https://pypi.org/project/google-genai/
- googleapis/python-genai, GitHub, read 2026-11-19, https://github.com/googleapis/python-genai
- Gemini 4 Hydrogen API Pricing and Day 0 Support on LiteLLM, LiteLLM docs, read 2026-11-19, https://docs.litellm.ai/blog/gemini-4-hydrogen
- Transports, Model Context Protocol specification 2025-11-25, read 2026-11-19, https://modelcontextprotocol.io/specification/2025-11-25/basic/transports
- EveryInfra data capability catalog, read 2026-11-19 00:14 SGT, https://api.everyinfra.com/api/v1/social/catalog
- Google rolls out Gemini 4 Hydrogen, finally replacing 3.8 Flash, Ars Technica, 2026-11-12, https://arstechnica.com/google/2026/11/google-rolls-out-gemini-4-hydrogen-finally-replacing-3-8-flash/
- Google's Gemini 4 Hydrogen outscores the bigger Argon just four weeks after its launch, The Decoder, 2026-11-12, https://the-decoder.com/googles-gemini-4-hydrogen-outscores-the-bigger-argon-just-four-weeks-after-its-launch/
- Google releases Gemini 4 Hydrogen, a lower-cost model said to outscore Argon, SiliconANGLE, 2026-11-12, https://siliconangle.com/2026/11/12/google-releases-gemini-4-hydrogen-a-lower-cost-model-said-to-outscore-argon/
- Google announces Gemini 4 Hydrogen, 9to5Google, 2026-11-12, https://9to5google.com/2026/11/12/gemini-4-hydrogen-launch/
- Google Makes Gemini 4 Hydrogen The Default Model In AI Mode, Search Engine Journal, 2026-11-12, https://www.searchenginejournal.com/google-gemini-4-hydrogen-default-ai-mode/597096/
- Google's Gemini 4 Hydrogen Turns Model Choice Into a Routing Decision, DevOps.com, 2026-11-16, https://devops.com/googles-gemini-4-hydrogen-turns-model-choice-into-a-routing-decision
- Gemini 4 Hydrogen pricing and benchmarks, OpenRouter, read 2026-11-19, https://openrouter.ai/google/gemini-4-hydrogen
- Gemini 4 Hydrogen intelligence, performance and price analysis, Artificial Analysis, read 2026-11-19, https://artificialanalysis.ai/models/gemini-4-hydrogen
- Gemini 4 Hydrogen is super slow, Reddit r/GoogleGeminiAI, 2026-11-18, https://www.reddit.com/r/GoogleGeminiAI/comments/1xzjcaq/gemini_4_hydrogen_is_super_slow/
- Gemini Hydrogen still hallucinating?, Reddit r/GoogleGemini, 2026-11-18, https://www.reddit.com/r/GoogleGemini/comments/1xzg6o7/gemini_hydrogen_still_hallucinating/
- Hydrogen and api usage, Reddit r/GeminiFeedback, 2026-11-18, https://www.reddit.com/r/GeminiFeedback/comments/1xzc8ra/hydrogen_and_api_usage_ignoring_in_chat_modes/
- FREE Gemini 4 Hydrogen vs $100 Claude Fable 5.2, YouTube, 2026-11-16, https://www.youtube.com/watch?v=-UnVlPimhqY
- Gemini 4 Hydrogen + Antigravity is WILD, YouTube, 2026-11-17, https://www.youtube.com/watch?v=XUUbeYlCrKA
- Gemini 4 Hydrogen Just Dropped (Personally Tested), YouTube, 2026-11-12, https://www.youtube.com/watch?v=bm8x0hopWTU
Reference BL-187