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.

Hand-drawn illustration: on a black ground, a curved track sweeps from lower left to upper right. A chip with a star and a yellow bolt speeds past a magnifier, a phone playing a video and a comment bubble. At the end, a funnel lets out one short page with a yellow line.

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.

ItemGemini 4 HydrogenSource
Model codegemini-4-hydrogenAI Studio model page
Context1,048,576 tokens, shared by input, thinking and outputModel page, long decode page
Output per response65,536 by default, up to 1,048,576 with long decodeModel page
Thinking levelslow, medium, high (default), xhigh. No minimalWhat's new page
CachingImplicit only. A prefix needs at least 4,096 tokensCaching page
ToolsFunction calling, structured outputs, Search and Maps grounding, URL context, code execution, computer use, remote MCPModel page, function calling page
Free tierYes. Search grounding is paid tier onlyPricing 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)InputOutputCached inputFree tierNote
Gemini 4 Hydrogen standard1.507.500.075YesSame price for all context sizes
Gemini 4 Hydrogen Batch or Flex0.753.750.0375NoFlex latency target 1 to 15 minutes
Gemini 4 Hydrogen Priority2.7013.50—NoServed before standard and Flex
Gemini 4 Carbon or Argon (to Nov 30)2.0010.000.10NoDefault thinking is medium
Gemini 4 Carbon or Argon (from Dec 1)4.0020.000.20NoIntroductory price ends
Gemini 3.8 Flash (2026)0.753.750.075Yes1.50 and 7.50 from Jan 1, 2027
Gemini 3.5 Flash-Lite0.302.50—YesFor 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.

Flow chart. The user task goes to Gemini 4 Hydrogen. In turn 1, the model sends four function calls at once: web, news, Reddit and YouTube. Local code turns them into EveryInfra requests and returns trimmed results to the model. In turn 2, the model uses those results to call Reddit comments and YouTube comments. In turn 3, it writes the report. A dashed line shows errors going back to the model.
With parallel calls, six tool calls need three model requests. Serial calls need seven.

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)CapabilityMain parametersResultsCharged (USD)Request ID
00:23:21 SGTweb/search"gemini 4 hydrogen pricing", US, English100.001389req_b0eb8916926c4a63
00:24:12 SGTgoogle_news/search"gemini 4 hydrogen", past week200.000792req_46a6a26a4fe94717
00:25:14 SGTreddit/search"gemini 4 hydrogen", by relevance40.000792req_52a46a7e4747419c
00:27:47 SGTreddit/search"gemini hydrogen", by newest140.000792req_877fe3fa24ee4bcb
00:27:58 SGTreddit/commentsLaunch post on r/singularity00 (refunded)req_21083fbada684332
00:28:26 SGTyoutube/search"gemini 4 hydrogen", by relevance100.000778req_86a01257f3cc42d7
00:28:37 SGTyoutube/commentsThe most viewed video400.000556req_58f6a18971374aaa
00:30:21 SGTreddit/commentsThread on r/GoogleGemini00 (refunded)req_e0151310d137402b
00:30:32 SGTweb/searchSpain, Spanish100.001389req_e0b072de7e274991
00:31:12 SGTweb/searchSingapore, Simplified Chinese100.001389req_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.

Screenshot of a dark code window. The top half shows a reddit/search request sent at 00:27:47 SGT and part of the response: the title "Gemini 4 Hydrogen is super slow", a masked author name and a charge of 0.000792 USD. The bottom half shows a reddit/comments response with empty results, charged set to false and refund status succeeded. Teal boxes mark three lines.
One call with results and one empty call. The empty call costs nothing and is refunded. EveryInfra live API response screenshot, 2026-11-19 00:27 SGT

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.

python
# 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.

bash
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%.

Horizontal bar chart. Nine data responses with results, two bars each. Grey is the estimated token count of the full response and teal is the count after trimming. Reddit by relevance drops from 8,173 to 622 tokens. Reddit by newest drops from 5,302 to 1,919. YouTube comments drop from 3,883 to 1,620. News drops from 2,970 to 1,305. Web search drops from 1,062 to 847.
Responses with long text and many fields shrink the most. Web search results are short already and shrink by 20%.
Response (estimated tokens)FullTrimmedCut
web/search US English, 10 results1,06284720.2%
google_news/search, 20 results2,9701,30556.1%
reddit/search by newest, 14 results5,3021,91963.8%
reddit/search by relevance, 4 results8,17362292.4%
youtube/search, 10 results2,17165070.1%
youtube/comments, 40 results3,8831,62058.3%
reddit/comments, empty24011—
Six calls of one check, total15,6286,35259.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.

CapabilityList price per call (USD)Per 1,000 calls (USD)Calls per check
web/search0.0013891.3891
google_news/search0.0007920.7921
reddit/search0.0007920.7921
reddit/comments0.0007920.7921
youtube/search0.0007780.7781
youtube/comments0.0005560.5561
One check, total0.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.

Stacked bar chart of the total cost of 1,000 tool calls. The dark part is the model token cost and the light part is the data cost of 0.85 USD. From top to bottom: Carbon at the December price, serial, full responses, no cache, 59.44 USD. Hydrogen serial, full, no cache, 22.82. Hydrogen serial, trimmed, 15.54. Carbon December price, parallel, trimmed, cache, 14.94. Hydrogen parallel, trimmed, no cache, 7.49. Hydrogen parallel, trimmed, cache, 6.14. Gemini 3.8 Flash 3.53. Hydrogen Flex 3.49.
The method matters more than the model. For Hydrogen, three changes cut the model cost from 21.97 USD to 5.29 USD.
1,000 tool calls (USD; model cost estimated at 4 characters per token and 500 output tokens per tool turn)ModelData callsTotal
Carbon December price, serial, full, no cache58.590.8559.44
Hydrogen, serial, full, no cache21.970.8522.82
Hydrogen, serial, full, cache12.080.8512.93
Hydrogen, serial, trimmed, no cache14.690.8515.54
Hydrogen, parallel, trimmed, no cache6.640.857.49
Hydrogen, parallel, trimmed, cache5.290.856.14
Carbon November price, parallel, trimmed, cache7.050.857.90
Carbon December price, parallel, trimmed, cache14.090.8514.94
Gemini 3.8 Flash 2026 price, parallel, trimmed, cache2.680.853.53
Hydrogen Flex, parallel, trimmed, cache2.640.853.49
Step on HydrogenModel cost per 1,000 tool callsChange
Serial, full responses, no cache$21.97Start
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.

Line chart. The x axis is the model request number and the y axis is input tokens. The serial, full-response line rises from 502 to 2,064, 5,534, 11,336, 12,076, 14,747 and 19,130 over seven requests. The parallel, trimmed line is 502, 5,723 and 7,854 over three requests.
Serial calls send all earlier responses again on each turn, for about 65,000 input tokens in total. Parallel calls with trimming use 14,079.

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.

Line chart. The x axis is output tokens per tool turn: 250, 500, 1,000, 2,000 and 4,000. The y axis is the total cost of 1,000 tool calls. Hydrogen rises from 5.87 to 16.68 USD. Carbon at the December price rises from 14.23 to 43.06 USD. Gemini 3.8 Flash rises from 3.38 to 8.82 USD.
From 500 to 4,000 output tokens per turn, the Hydrogen total rises from 6.14 USD to 16.68 USD, a little above Carbon at 500 tokens.
Output tokens per turnHydrogenCarbon December priceGemini 3.8 Flash 2026 price
2505.8714.233.38
5006.1414.943.53
1,0007.6418.964.28
2,00010.6526.995.80
4,00016.6843.068.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.

Grouped bar chart of Gemini 4 Hydrogen scores at four thinking levels, low, medium, high and xhigh, on two benchmarks. AutomationBench scores are 60.5, 72.0, 74.4 and 76.1. Terminal-Bench 4.0 scores are 6.6, 29.3, 54.0 and 53.5.
Low drops the most on long terminal tasks. For simple routing tool calls, the gap between low and high is much smaller.
Thinking levelAutomationBenchTerminal-Bench 4.0Intelligence index
low60.56.626.9
medium72.029.341.2
high (default)74.454.050.8
xhigh76.153.553.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.

Bar chart of the cost of 1,000 web lookups. Google Search grounding after the free quota costs 14 USD. EveryInfra web/search costs 1.389 USD. The first is 10.1 times the second.
The first 5,000 grounding requests each month are free. After that, each search is billed.
ItemGoogle Search groundingEveryInfra `web/search`
Free quota5,000 requests per month, shared by Gemini 3 and laterNone
Price after the quota$14 per 1,000 requests$1.389 per 1,000 calls
Daily cap1,500 requestsPer-minute key limit
Free tier of GeminiNot available for HydrogenWorks with any model
What you getCitations in the model answerRaw 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".

Illustration. A large pile of messy paper pours from the upper left into a sieve. Below the sieve, only a few neat teal cards fall out. A line carries the cards to a fast yellow robot on the right.
Keywords, sort order and field trimming do the same job: filter the data before the model sees it.
Search (SGT)KeywordSortPostsAbout the modelLikes and comments on those posts
00:25:14 SGTgemini 4 hydrogenrelevance400 and 0
00:27:47 SGTgemini hydrogennewest14616 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)ArticlesExamples
2026-11-1211Three blog.google posts, Ars Technica, The Decoder, 9to5Google, SiliconANGLE, VentureBeat
2026-11-134GitHub changelog (Copilot), Mashable, a Medium comparison with Claude Haiku 5.5
2026-11-151Tom's Guide on five things to do for free
2026-11-163DevOps.com, TechRadar, AI Insider
2026-11-171Google 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.

python
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.

Screenshot of a dark code window. A tools/list request sent to api.everyinfra.com/mcp at 00:29:33 SGT and part of the response. The first teal box says 12 tools, 16,760 characters, about 4,190 tokens. The middle lists the everyinfra_call_api and everyinfra_get_job tools. The second teal box says 2,620 characters, about 655 tokens, when only these two are allowed.
A remote MCP server sends its tool descriptions on every turn. With two allowed tools, the size drops by over 80%. EveryInfra MCP tools/list live response screenshot, 2026-11-19 00:29 SGT
MethodTool description sizeTurns for one checkWho picks the capability
Six own functions1,810 characters, about 452 tokens3 with parallel callsYour code
Remote MCP, all 12 tools16,760 characters, about 4,190 tokens3 or 4, with a catalog lookupThe model
Remote MCP, two allowed tools2,620 characters, about 655 tokens3 or 4, with a catalog lookupThe 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.

RankVideoDate (UTC)ViewsComments
1FREE Gemini 4 Hydrogen vs $100 Claude Fable 5.22026-11-1611,362157
2Gemini 4 Hydrogen + Antigravity is WILD2026-11-175,5242
3Gemini 4 Hydrogen Just Dropped (Personally Tested)2026-11-12193,622268
4NEW Gemini 4 Hydrogen vs. Gemini 4 Argon2026-11-173,7045
5The NEW Gemini 4 Hydrogen is INSANE2026-11-129,1712
6Gemini 4 Hydrogen Is the BEST Flash Model Yet – Full Test!2026-11-1397,332316
7Gemini 4 Hydrogen: Google's New General-Purpose Model2026-11-163610
813 Gemini 4 Hydrogen Builds: Is It Better Than Opus?2026-11-174570
9Google Just Released Gemini 4 Hydrogen!2026-11-155,9581
10Gemini 4 Hydrogen vs Claude Opus 5.5: 10-Round SHOWDOWN2026-11-123,2002

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.

LikesWhat the comment says (6 selected)Topic
178A joke about H2O and the namesNames
170Carbon announced weeks ago and still out of reach, Hydrogen open to allAccess
86Finally a model people can use todayAccess
31Likes the new model namesNames
14Carbon is already on the APIAccess
11Argon gives about five prompts on AI ProUsage

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.

SettingGemini 3.8 FlashGemini 4 Hydrogen
Model codegemini-3.8-flashgemini-4-hydrogen
Context1M input and 64K output, separate1,048,576 shared by input, thinking and output
Default thinkingmediumhigh, plus the new xhigh
minimalAcceptedReturns an error
Explicit cachingSupportedNot supported, implicit only
Search grounding on the free tierYesNo
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.

ErrorChargedWhat goes to the modelWhat the code does
EveryInfra 429NoNothing, the tool layer retriesRead error.retry_after, add 1 to 6 seconds of jitter
200 with count 0Refunded{"count": 0} and a note "not retrieved"The report does not say "no discussion"
EveryInfra 503 unavailableNoThe error code and messageWait 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

  1. 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/
  2. Gemini 4 Hydrogen model page, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/models/gemini-4-hydrogen
  3. 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
  4. Gemini Developer API pricing, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/pricing
  5. Function calling, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/function-calling
  6. Interactions API overview, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/interactions-overview
  7. Understand and count tokens, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/tokens
  8. Rate limits, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/rate-limits
  9. Context caching, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/caching
  10. Thinking, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/thinking
  11. Choosing a model, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/choosing-a-model
  12. Grounding with Google Search, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/google-search
  13. Batch API, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/batch-api
  14. Flex inference, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/flex-inference
  15. Priority inference, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/priority-inference
  16. Structured outputs, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/structured-output
  17. URL context, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/url-context
  18. Text generation, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/text-generation
  19. Long decode, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/long-decode
  20. Gemini 4 Carbon model page, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/models/gemini-4-carbon
  21. 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
  22. Gemini 3.8 Flash model page, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/models/gemini-3.8-flash
  23. Models, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/models
  24. Billing, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/billing
  25. Computer use, Google AI Studio docs, read 2026-11-19, https://aistudio.google.com/docs/computer-use
  26. Gemini 4 Hydrogen model card, Google DeepMind, 2026-11-12, https://deepmind.google/models/model-cards/gemini-4-hydrogen/
  27. Introducing Gemini 4 Carbon, blog.google, 2026-10-28, https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-carbon/
  28. Gemini 4 Hydrogen in Google Antigravity, Antigravity blog, read 2026-11-19, https://antigravity.google/blog/gemini-4-hydrogen-in-google-antigravity/
  29. Gemini 4 Hydrogen in GitHub Copilot, GitHub changelog, 2026-11-13, https://github.blog/changelog/2026-11-13-gemini-4-hydrogen-in-github-copilot/
  30. google-genai, PyPI, read 2026-11-19, https://pypi.org/project/google-genai/
  31. googleapis/python-genai, GitHub, read 2026-11-19, https://github.com/googleapis/python-genai
  32. 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
  33. Transports, Model Context Protocol specification 2025-11-25, read 2026-11-19, https://modelcontextprotocol.io/specification/2025-11-25/basic/transports
  34. EveryInfra data capability catalog, read 2026-11-19 00:14 SGT, https://api.everyinfra.com/api/v1/social/catalog
  35. 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/
  36. 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/
  37. 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/
  38. Google announces Gemini 4 Hydrogen, 9to5Google, 2026-11-12, https://9to5google.com/2026/11/12/gemini-4-hydrogen-launch/
  39. 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/
  40. 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
  41. Gemini 4 Hydrogen pricing and benchmarks, OpenRouter, read 2026-11-19, https://openrouter.ai/google/gemini-4-hydrogen
  42. Gemini 4 Hydrogen intelligence, performance and price analysis, Artificial Analysis, read 2026-11-19, https://artificialanalysis.ai/models/gemini-4-hydrogen
  43. 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/
  44. Gemini Hydrogen still hallucinating?, Reddit r/GoogleGemini, 2026-11-18, https://www.reddit.com/r/GoogleGemini/comments/1xzg6o7/gemini_hydrogen_still_hallucinating/
  45. 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/
  46. FREE Gemini 4 Hydrogen vs $100 Claude Fable 5.2, YouTube, 2026-11-16, https://www.youtube.com/watch?v=-UnVlPimhqY
  47. Gemini 4 Hydrogen + Antigravity is WILD, YouTube, 2026-11-17, https://www.youtube.com/watch?v=XUUbeYlCrKA
  48. Gemini 4 Hydrogen Just Dropped (Personally Tested), YouTube, 2026-11-12, https://www.youtube.com/watch?v=bm8x0hopWTU

Reference BL-187

Google Analytics needs consent. Privacy