Short answer. As of 13 November 2026 the Gemini API documentation points to gemini-4-hydrogen as the starting point. It reached its stable release on 12 November, has a free tier and costs 1.50 dollars per million input tokens and 7.50 per million output tokens. Above it sits the pair gemini-4-carbon and gemini-4-argon, with no free tier, at 2 and 10 dollars until 30 November and at 4 and 20 from 1 December. Below it sits gemini-3.5-flash-lite, at 0.30 and 2.50 dollars, which the same documentation recommends for classification, routing and sub-second latency targets. The former favourite gemini-3.8-flash is now described as the previous generation. Before you choose, mark two dates: 1 December and 1 January 2027 change the prices of Argon, Carbon and 3.8 Flash.
This is the first of six articles on the Gemini API. I am not affiliated with Google, and Gemini is here the subject matter, not a tool I recommend by default. Every number has beside it the page it comes from, opened on 13 November 2026. Where a page does not say something (for example the knowledge cutoff of the models) I say so, rather than filling the gap. In these articles no listing calls the API: I used no keys and no accounts. The scripts below calculate and check, and the prices they use are the ones I read at the source.
The problem: names change faster than projects do
If you have a project that lasts longer than a quarter, the question is not "which model is the best" but "which model will still exist, at that price, when I have to maintain it". The dates on the deprecations page let you measure this. Gemini 3.7 Flash came out on 13 August 2026, Gemini 3.8 Flash on 2 September, Gemini 4 Argon on 13 October, Gemini 4 Carbon on 10 November and Gemini 4 Hydrogen on 12 November: five text models in thirteen weeks. The changelog entry of 8 October declared 3.7 Flash deprecated eight weeks after its debut.
"Deprecated" does not mean "shut down". For gemini-3.7-flash the deprecations page lists "N/A" as the shutdown date and gemini-3.8-flash as the replacement, adding that the endpoint is not shut down and that API requests are automatically routed to the replacement. The same goes for gemini-3.5-flash, routed to gemini-3.6-flash. If your code contains a deprecated identifier, the service can change model under your feet without you editing a line, and the regression tests that passed yesterday measure a different model today.
The model map on 13 November 2026
The models page groups them by family. Below are the ones that matter to people writing software, leaving out the models for music, video, images and voice, which deserve another article. The prices are those of the Standard tier on the pricing page, per million tokens, and the output price includes reasoning tokens.
| Model | Role according to the documentation | Free tier | Input / output (dollars per million) |
|---|---|---|---|
gemini-4-hydrogen | Default for everyday code and agents; stable since 12 November | Yes | 1.50 / 7.50 |
gemini-4-argon | Frontier reasoning, fewer tokens per turn than Carbon; stable since 13 October | No | 2.00 / 10.00 until 30 November; 4.00 / 20.00 from 1 December |
gemini-4-carbon | The strongest model, for hard problems; stable since 10 November | No | Same as Argon |
gemini-3.8-flash | Previous generation of Flash; stable since 2 September | Yes | 0.75 / 3.75 until 31 December 2026; 1.50 / 7.50 from 1 January 2027 |
gemini-3.5-flash-lite | The fastest and cheapest; high volume | Yes (without caching) | 0.30 / 2.50 |
gemini-3.1-flash-lite | Cheap; shutdown possible from 7 May 2027, replacement 3.5 Flash-Lite | Yes (without caching) | 0.25 / 1.50 |
gemini-3.1-pro-preview | Preview | No | 2.00 / 12.00 up to 200,000 prompt tokens; 4.00 / 18.00 above |
The pages for Hydrogen, Argon, Carbon, 3.8 Flash and the two Flash-Lite models report the same technical base: input of text, images, video, audio and PDF, text-only output, 1,048,576 input tokens (in the Gemini 4 models it is a single window for input and output) and 65,536 tokens of synchronous output. In the Gemini 4 models the output can reach 1,048,576 tokens with "long decode", which splits the generation into consecutive jumps: with background: true and an output limit above 65,536 tokens the server runs them, in jumps of 64 thousand tokens, or you continue on the client side. One thing stands out in the table: Carbon and Argon have the same price per token. The difference, according to the Argon page, lies in the tokens spent per turn (fewer than Carbon), not in the price list: that is a statement by Google, which I have not measured.
A consequence that follows from the tables alone: from 1 January 2027 gemini-3.8-flash costs the same as Hydrogen (1.50 and 7.50), and so stops being the economical choice. The script further down checks this too. Anyone who writes "3.8 Flash" in their code today to save money is facing a deadline, not a saving.
What Google says about how to choose
The "What's new in Gemini 4 Hydrogen" page has a section devoted to choosing. I report its substance, and these are the vendor's indications: none is a benchmark and none has been verified by me.
- Hydrogen is recommended for everyday programming, interactive applications, agents that use tools, multimodal documents and parallel sub-agents, and it is the recommended upgrade from 3.8 Flash and earlier models.
- Carbon spends more reasoning tokens per turn to test hypotheses and edge cases: hard architectures, debugging, science, security audits.
- Argon is for most long-running advanced tasks, with lower token consumption than Carbon.
- Flash-Lite stays for classification, routing and sub-second latency targets.
Read this list as a map of roles, not a ranking: the entries run from the most common to the rarest in a typical project, and changing the order would not change the meaning. The criterion that holds them together is how much reasoning per request you need. The entries do not say, and neither do I, how many more mistakes Hydrogen makes than Carbon on your task: that measurement is yours to make, and the procedure is in the section "How to choose".
What it really costs: a calculation you can redo
A price per million tokens says little until you apply it to a workload. The script takes the prices from the table, with the date from which they apply, and calculates the cost of 10,000 requests of 3,000 input tokens and 500 output tokens. It does so twice in different ways: with exact fractions, and by summing request by request with Decimal; the assert line stops the script if the two results diverge. A separate line shows the effect of a thousand reasoning tokens per request, an assumption of mine, because reasoning is billed as output. The output is identical across two consecutive runs.
"""Cost of a workload using the prices on the Gemini pricing page
(consulted on 2026-11-13). Prices in dollars per million tokens."""
from datetime import date
from decimal import Decimal as D
from fractions import Fraction as F
# (model, valid from) -> (input, output). The output price includes reasoning.
PRICES = {
"gemini-4-carbon": [(date(2026, 11, 10), "2.00", "10.00"), (date(2026, 12, 1), "4.00", "20.00")],
"gemini-4-argon": [(date(2026, 10, 13), "2.00", "10.00"), (date(2026, 12, 1), "4.00", "20.00")],
"gemini-4-hydrogen": [(date(2026, 11, 12), "1.50", "7.50")],
"gemini-3.8-flash": [(date(2026, 9, 2), "0.75", "3.75"), (date(2027, 1, 1), "1.50", "7.50")],
"gemini-3.5-flash-lite": [(date(2026, 7, 21), "0.30", "2.50")],
"gemini-3.1-flash-lite": [(date(2026, 5, 7), "0.25", "1.50")],
}
def price_on(model, day):
valid = [r for r in PRICES[model] if r[0] <= day]
return valid[-1][1:] if valid else None
def cost(model, day, requests, tok_in, tok_out, tok_thinking=0):
p = price_on(model, day)
if p is None:
return None
total_in = requests * tok_in
total_out = requests * (tok_out + tok_thinking)
return (F(p[0]) * total_in + F(p[1]) * total_out) / 1_000_000
def cost_check(model, day, requests, tok_in, tok_out, tok_thinking=0):
"""Second, independent calculation: sum request by request with Decimal."""
p = price_on(model, day)
one = (D(p[0]) * tok_in + D(p[1]) * (tok_out + tok_thinking)) / D(1_000_000)
total = D(0)
for _ in range(requests):
total += one
return total
LOAD = dict(requests=10_000, tok_in=3_000, tok_out=500)
DAYS = [date(2026, 11, 13), date(2026, 12, 1), date(2027, 1, 1)]
print("10,000 requests, 3,000 input tokens and 500 output tokens each (dollars)")
print(f"{'model':24}" + "".join(f"{g.isoformat():>12}" for g in DAYS))
for m in PRICES:
row = f"{m:24}"
for g in DAYS:
c = cost(m, g, **LOAD)
if c is None:
row += f"{'n/a':>12}"
continue
assert cost_check(m, g, **LOAD) == D(c.numerator) / D(c.denominator)
row += f"{float(c):>12.2f}"
print(row)
extra = cost("gemini-4-hydrogen", DAYS[0], **LOAD, tok_thinking=1_000)
print(f"Hydrogen with 1,000 reasoning tokens (assumption) per request: {float(extra):.2f}")
print("Hydrogen and 3.8 Flash have the same price from 2027-01-01:",
price_on("gemini-4-hydrogen", DAYS[2]) == price_on("gemini-3.8-flash", DAYS[2]))
# Two HYPOTHETICAL scenarios (volumes made up for the example, replace them with yours)
SCENARIOS = [
("ticket triage", "gemini-3.5-flash-lite", date(2026, 11, 13), dict(requests=20_000, tok_in=800, tok_out=100)),
("code review", "gemini-4-hydrogen", date(2026, 11, 13), dict(requests=500, tok_in=40_000, tok_out=6_000)),
("code review", "gemini-4-argon", date(2026, 11, 13), dict(requests=500, tok_in=40_000, tok_out=6_000)),
("code review", "gemini-4-argon", date(2026, 12, 1), dict(requests=500, tok_in=40_000, tok_out=6_000)),
]
print()
for name, m, g, load in SCENARIOS:
assert cost_check(m, g, **load) == D(cost(m, g, **load).numerator) / D(cost(m, g, **load).denominator)
print(f"{name:20} {m:24} {g} {float(cost(m, g, **load)):8.2f} dollars per month")
# Output:
# 10,000 requests, 3,000 input tokens and 500 output tokens each (dollars)
# model 2026-11-13 2026-12-01 2027-01-01
# gemini-4-carbon 110.00 220.00 220.00
# gemini-4-argon 110.00 220.00 220.00
# gemini-4-hydrogen 82.50 82.50 82.50
# gemini-3.8-flash 41.25 41.25 82.50
# gemini-3.5-flash-lite 21.50 21.50 21.50
# gemini-3.1-flash-lite 15.00 15.00 15.00
# Hydrogen with 1,000 reasoning tokens (assumption) per request: 157.50
# Hydrogen and 3.8 Flash have the same price from 2027-01-01: True
#
# ticket triage gemini-3.5-flash-lite 2026-11-13 9.80 dollars per month
# code review gemini-4-hydrogen 2026-11-13 52.50 dollars per month
# code review gemini-4-argon 2026-11-13 70.00 dollars per month
# code review gemini-4-argon 2026-12-01 140.00 dollars per month
The ratio between the high and low tiers for the same workload is about seven to one today (110 against 15 dollars) and almost fifteen to one from December (220 against 15). This is the real trade-off: Argon is not "better" in absolute terms, it is more expensive per request, and the useful question is how many more requests the cheap model gets wrong on your task. The Argon and Carbon columns do not change between 1 December and 1 January because their price changes only once. The 3.8 Flash row, by contrast, changes at the second date. The assumption of a thousand reasoning tokens takes Hydrogen from 82.50 to 157.50 dollars: in models that reason, the reasoning can weigh as much as the answer. The calculation does not include batch, cache or discounts, which the pricing page lists separately.
Deprecated does not mean shut down: a model registry
The second script is small and serves a habit: the model identifier lives in a single constant, with a date beside it, and a function says what the documentation thinks of it. The ROUTED and SHUTDOWN tables record by hand the rows of the deprecation pages and of the changelog of 2 November, which announces the routing of gemini-2.5-pro and gemini-2.5-flash starting on 1 December 2026, billed at the replacement's rates. The status function takes the date as an argument instead of reading the clock, so that the output is reproducible; in production you would pass date.today().
"""A single place where the project declares the model, and a check that says
what the documentation thinks of it (deprecations and changelog pages, 2026-11-13)."""
from datetime import date
MODEL = "gemini-4-hydrogen" # chosen on 2026-11-13, to be re-measured
# id -> (routing start, replacement, note)
ROUTED = {
"gemini-3.7-flash": (date(2026, 10, 8), "gemini-3.8-flash", "endpoint not shut down, requests routed"),
"gemini-3.5-flash": (date(2026, 10, 8), "gemini-3.6-flash", "endpoint not shut down, requests routed"),
"gemini-2.5-pro": (date(2026, 12, 1), "gemini-3.8-flash", "routed and billed at the replacement's rates"),
"gemini-2.5-flash": (date(2026, 12, 1), "gemini-3.5-flash-lite", "routed and billed at the replacement's rates"),
}
# id -> earliest possible shutdown date, as written on the page
SHUTDOWN = {"gemini-3.1-flash-lite": (date(2027, 5, 7), "gemini-3.5-flash-lite")}
CURRENT = {"gemini-4-carbon", "gemini-4-argon", "gemini-4-hydrogen", "gemini-3.8-flash",
"gemini-3.6-flash", "gemini-3.5-flash-lite", "gemini-3.1-flash-lite"}
def status(model_id: str, today: date) -> str:
if model_id in ROUTED:
since, replacement, note = ROUTED[model_id]
if today >= since:
return f"ROUTED to {replacement} since {since}: {note}"
return f"soon routed to {replacement} on {since}: change now"
if model_id in SHUTDOWN:
when, replacement = SHUTDOWN[model_id]
return f"ok today; shutdown possible from {when}, replacement {replacement}"
if model_id in CURRENT:
return "ok"
return "UNKNOWN: not in the registry, check the models page"
for day in (date(2026, 11, 13), date(2026, 12, 1)):
print(f"--- {day}")
for mid in (MODEL, "gemini-3.7-flash", "gemini-2.5-flash", "gemini-3.1-flash-lite", "gemini-5-neon"):
print(f"{mid:24} {status(mid, day)}")
# Output:
# --- 2026-11-13
# gemini-4-hydrogen ok
# gemini-3.7-flash ROUTED to gemini-3.8-flash since 2026-10-08: endpoint not shut down, requests routed
# gemini-2.5-flash soon routed to gemini-3.5-flash-lite on 2026-12-01: change now
# gemini-3.1-flash-lite ok today; shutdown possible from 2027-05-07, replacement gemini-3.5-flash-lite
# gemini-5-neon UNKNOWN: not in the registry, check the models page
# --- 2026-12-01
# gemini-4-hydrogen ok
# gemini-3.7-flash ROUTED to gemini-3.8-flash since 2026-10-08: endpoint not shut down, requests routed
# gemini-2.5-flash ROUTED to gemini-3.5-flash-lite since 2026-12-01: routed and billed at the replacement's rates
# gemini-3.1-flash-lite ok today; shutdown possible from 2027-05-07, replacement gemini-3.5-flash-lite
# gemini-5-neon UNKNOWN: not in the registry, check the models page
Three behaviours are worth reading in the output. 3.7 Flash is already routed; 2.5 Flash will be from 1 December, and the script flags it in advance with "change now"; 3.1 Flash-Lite works, but the page says the shutdown date is the earliest possible one and that the exact date will be communicated with notice. One thing I have not verified: whether the model field of the response reports the model actually used after a routing. That is why the check lives in your registry and not in the response. The last line of each of the two dates shows the "unknown" case: gemini-5-neon is an identifier invented on purpose for the test and does not correspond to any announced model. It is worth recording for each call the requested model, the date and the tokens used, so you can notice a change from the cost.
The old families should be treated separately. Since 18 September 2026 access to the 2.5 models has been limited to those who have already actively used them, and for new projects the changelog indicates 3.5 Flash-Lite or 3.8 Flash, and the models page Hydrogen or 3.5 Flash-Lite. gemini-2.5-flash-lite is not deprecated and continues to be served "until further notice". The models gemini-2.0-flash and gemini-2.0-flash-lite appear in the section of models already shut down, with a shutdown date of 1 June 2026.
How to choose: a criterion that does not depend on trust
No table decides for you, and for that reason I report no benchmarks: I have not opened any at the source, and published benchmarks age faster than prices. The procedure I would use has four steps and costs less than an afternoon. The order matters: if you skip the second step, the numbers in the third are not comparable.
- Gather twenty real cases of your task, each with the answer you consider correct, taken from logs, tickets or repositories. Twenty is not enough for statistics, but it is enough to see a gross difference.
- Start from the cheapest model that could plausibly work and move up only if it fails. Moving up is a one-line change; moving down after building on an expensive model is a debt.
- Measure three things for each model: percentage of acceptable answers, latency and cost per request, with the tokens read from the usage field of the response.
- Write the date of the measurement in the README, because in two months the chosen model might be routed elsewhere and you will want to know when you measured.
Step two explains why the procedure starts from a cheap model and not from Hydrogen: starting from below turns the choice into a test, while starting from above turns it into a conviction. There is a second knob besides the model: the reasoning level. Hydrogen supports low, medium, high (default) and xhigh; Carbon and Argon support low, medium (default) and high; for 3.5 Flash-Lite the comparison page indicates minimal as the default, while 3.8 Flash returns an error if you ask for minimal. For Hydrogen Google recommends trying all the levels with a high output token limit and choosing the lowest one that reaches the required quality: the level is the most direct lever on cost and latency.
Free tier and data: "free" has a price
The free tier exists for Hydrogen, 3.8 Flash, 3.6 Flash and the Flash-Lite models, but not for Argon, Carbon and 3.1 Pro. For prototyping it is excellent. For customer data it is not: the terms say that in the unpaid services Google uses the submitted content and the responses to improve its products, that human reviewers may read inputs and outputs, and they urge you not to submit sensitive, confidential or personal information. In the paid services the terms say that prompts and responses are not used to improve the products, and that Google logs them for a limited period to detect violations of the usage policy. Details, retention and quotas are the subject of article 5.
Two hypothetical scenarios, with the script's numbers
The volumes are made up by me for the example: replace them with your own. The amounts come from the last part of the script's output above. In the first scenario a ticket triage service uses gemini-3.5-flash-lite: 20,000 tickets a month of 800 input tokens and 100 output tokens cost 9.80 dollars. It is a classification job with a very short, checkable output: if the model gets the category wrong on one ticket in twenty, you see it in a sample and the cost of being wrong is small.
In the second scenario an automated code review handles 500 changes a month, each with 40,000 input tokens and 6,000 output tokens including reasoning ones. With Hydrogen it costs 52.50 dollars; with Argon 70 dollars until 30 November and 140 from 1 December. Neither number says which model is better. They say that, at equal tokens, Argon after 30 November would cost about 2.7 times Hydrogen (140 against 52.50): to cost the same as Hydrogen it would have to spend less than 37.5% of its tokens, a gap that your test on the twenty cases has to show. The calculation assumes it consumes the same tokens, and Google says Argon spends fewer than Carbon, not fewer than Hydrogen.
What you can do now
You can read the model table and tell stable, preview and deprecated apart. You can calculate the cost of a workload using the dates of the price-list changes, and you know why an identifier written in ten places in the code is a risk. You have a selection criterion that starts from the cheap model and a registry that warns you before a model is routed elsewhere. The next step is the first real call: in article 2 you will find the key, the SDK and the choice between server-side state and stateless mode.
The series
- This article: models and pricing.
- Gemini API: key, SDK and Interactions API
- Gemini: functions, JSON and Google Search
- Gemini: 1M-token context, thinking, caching
- Gemini API: tiers, limits and data privacy
- After Gemini CLI: Antigravity and gemini-api
The articles are meant to be read in this order, because each one uses the model and the constant of the previous one. If instead you are interested in the protocol these models use to connect to external tools, there is the introduction to the Model Context Protocol on this site.
Frequently asked questions
Which Gemini model suits an app that starts from scratch?
The documentation indicates gemini-4-hydrogen as the default and as the recommended upgrade from 3.8 Flash: it has a free tier and costs 1.50 dollars per million input tokens and 7.50 per million output tokens. Argon and Carbon have no free tier. Move up only if a measurement on your own task shows you need to.
Will Gemini prices stay the same?
No. The pricing page of 13 November 2026 takes Argon and Carbon from 2 to 4 dollars for input and from 10 to 20 for output on 1 December 2026, and 3.8 Flash from 0.75 to 1.50 for input and from 3.75 to 7.50 for output on 1 January 2027. Always date the cost you estimate.
Can I still use Gemini 2.5?
Only if you already have: since 18 September 2026 access to the 2.5 models has been limited to those who have actively used them. From 1 December 2026 gemini-2.5-pro and gemini-2.5-flash will be routed to other models and billed at their rates.
Sources
- Gemini Developer API pricing - Standard prices per million tokens, dates of price-list changes, free tier, search with Google at 14 dollars per 1,000; consulted on 2026-11-13
- Gemini API, Models - list of models, notices about the 2.5 models; consulted on 2026-11-13
- Gemini 4 Hydrogen (model page) - inputs, token limits, capabilities, reasoning levels; consulted on 2026-11-13
- What's new in Gemini 4 Hydrogen - Google's guidance on choosing between Hydrogen, Carbon, Argon and Flash-Lite, reasoning levels; consulted on 2026-11-13
- Gemini 3.8 Flash (model page) - token limits and the error returned by
minimal; consulted on 2026-11-13 - Long decode - output in jumps of 64 thousand tokens, in the background or with client-side continuation; consulted on 2026-11-13
- Latest Gemini models - comparison of the four models, default reasoning levels; consulted on 2026-11-13
- Gemini API, Release notes - release dates from 13 October to 12 November, deprecations of 8 October and 2 November, access to the 2.5 models on 18 September; consulted on 2026-11-13
- Gemini deprecations - release dates, shutdowns and replacements; consulted on 2026-11-13
- Gemini API Additional Terms of Service - use of data in the free and paid services; consulted on 2026-11-13
Commenti
Caricamento commenti...
Sign in to comment