Gemini 4 Neon API 怎么收费?四个思考档位下一个任务要花多少钱
讲清 Gemini 4 Neon API 价格:每百万 token 输入 $3、输出 $15,缓存、Batch、Priority 费率和搜索费用,以及从 low 到 xhigh 每个任务的实际成本,附经过测试的计算器。
在 Google 的 Standard 付费层级上,Gemini 4 Neon 的价格是每百万输入 token $3.00、每百万缓存输入 token $0.15、每百万输出 token $15.00,思考 token 按输出计费。Neon 没有免费层级。一个任务实际花多少钱,主要由思考档位决定:在 Artificial Analysis 的基准任务上,Neon 每个任务的平均成本在 low 档约 $0.75,medium 档 $1.90,默认的 high 档 $3.74,xhigh 档 $6.44。 各档位的单 token 价格完全相同,变化的是模型在完成任务前读入和写出的 token 数量。
本文列出 Google 公布的全部 Neon 费率,解释为什么单 token 价格不等于单任务价格,并给出一个小型 Python 计算器,用三个示例工作负载对比 Gemini 4 Hydrogen 和 Gemini 4 Carbon 的价格(Carbon 分 12 月 1 日涨价前后两种情况)。
本文由 Ofox 发布。所有价格均为 Google Gemini Developer API 的美元标价,已于 2026 年 11 月 19 日对照 Google 实时价格页核对。截至该日,Ofox 尚未提供 Gemini 4 Neon(我们带鉴权调用 GET /v1/models,返回了 google/gemini-4-argon 和 google/gemini-4-hydrogen,没有 Neon,也没有 Carbon)。文中没有任何 Ofox 价格。我们撰写本文时没有调用 Neon:单任务数据来自 Artificial Analysis,工作负载示例是我们基于假设 token 数做的计算。
Gemini 4 Neon API 各服务层级价格
Google 的 Neon 价格表(英文)列出了四个推理层级。所有费率的单位都是每 1,000,000 token 的美元价格。
| 服务层级 | 输入 | 缓存输入 | 输出(含思考) |
|---|---|---|---|
| Standard | $3.00 | $0.15 | $15.00 |
| Batch | $1.50 | $0.075 | $7.50 |
| Flex | $1.50 | $0.075 | $7.50 |
| Priority | $5.40 | $0.27 | $27.00 |
Google 在这些数字旁边还写了几条条件:
- 没有免费层级。 价格页在 Free 层级的每一行 Neon 价格处都标注为 “Not available”,Neon 开发者指南(英文)也说明该模型只在 Gemini API 的付费层级提供。你需要一个已开通结算的项目。
- 整个上下文窗口统一定价。 Google 的描述是 Neon “flat pricing across the full 1M context window”(在完整的 1M 上下文窗口内统一定价)。提示超过 200k token 也不会切换到更高费率,而早先部分 Gemini 模型有这种分段。窗口大小为 1,048,576 token,由输入、思考和输出共用。
- 思考算作输出。 输出这一行的标签是 “including thinking tokens”。一次响应如果有 2,000 个可见 token 和 30,000 个思考 token,按 32,000 个输出 token 计费。
- 看不见的输入也算输入。 Google 把”使用 grounding 时的内部工具系统指令和函数声明”计为计费 token。你自己写的提示并不是全部输入。
- 缓存输入只有隐式缓存。 Neon 不支持显式缓存(
cachedContents、caches.create),所以没有缓存存储费需要另算。$0.15 的费率只适用于真正命中隐式缓存的 token。
Batch 和 Flex 把三项 token 费率都减半,Priority 是 Standard 的 1.8 倍。价格表上能看到的差别仅此而已。它没有告诉你 Batch 的完成时间、Flex 请求被丢弃的频率,也没有说明 Priority 能为你的流量省下多少延迟。把时间敏感的工作负载迁过去之前,先看 Google 的优化指南(英文)。
在 token 之外另收的工具费用
| 工具 | Google 对 Neon 的计费方式 |
|---|---|
| Grounding with Google Search | 每月 5,000 次免费搜索请求,由 Gemini 3 及更新的所有模型共用,超出后每 1,000 次 $14。模型执行的每一条搜索查询都单独计费,你的一次请求可能触发多条查询。在 Gemini Developer API 上,默认上限是每个项目每天 1,500 次 grounding 请求。 |
| Grounding with Google Maps | 每月 5,000 次免费请求(共用规则相同),超出后每 1,000 次查询 $14 |
| 代码执行 | 不单独收费。生成的代码和执行结果在生成时按输出计费,模型再读回时按输入计费 |
| URL context | 按输入 token 计费 |
| 文件搜索 | embedding 费用,加上检索到的 token 按 Neon 的 token 费率计费 |
Search 和 Maps 两行出现在 Neon 的 Standard 和 Priority 价格表里。Batch 和 Flex 价格表没有列出 Search 价格,所以下面的计算器在这两个层级上遇到需付费的搜索时会直接报错,不去猜测价格。
为什么单 token 价格不等于单任务价格
一个任务指的是:从开始到你拿到可接受的结果为止,模型处理的全部内容。单次请求的计算方式如下:
request_cost = (uncached_input × input_rate
+ cached_input × cached_rate
+ output_incl_thinking × output_rate) / 1,000,000
task_cost = sum(request_cost for every request in the task)
+ billable_search_queries × $0.014
uncached_input 是总输入减去命中缓存的部分,所以缓存 token 不会被重复计费。公式里”任务中的每一次请求”包括 Agent 的各轮调用、工具往返,以及没通过你验收检查的重试。
有两个因素会让这个总和远高于单 token 价格给人的印象。
思考会成倍放大输出。 Google 指南对 low 的描述是 “fewest tokens, lowest latency”(token 最少、延迟最低),对 xhigh 的描述是 “most tokens, deepest reasoning”(token 最多、推理最深)。在 Artificial Analysis 的任务上(见下表),Neon 每个任务平均输出约 21,700 token(low)和 141,600 token(xhigh)。单 token 价格相同,token 数却是 6.5 倍。
Agent 会反复读取上下文。 Agent 循环的每一轮都会把截至当前的对话作为输入发送。从 Artificial Analysis 对 Neon xhigh 的单任务成本拆分推算,每个任务约有 1,200 万输入 token,其中约 1,100 万命中缓存。在这种工作负载下,尽管输出费率是输入的五倍,输入花的钱仍然比输出多。
low、medium、high、xhigh 各档的单任务成本
Artificial Analysis(英文)在 Neon 的每个思考档位上运行其 Intelligence Index 评测,并按 Google 标价报告单任务成本(Neon 用的是当前 $3/$15 费率;Carbon 的情况见下一节)。我们在 2026 年 11 月 19 日查看了该页面。页面可见文字给出了 xhigh 的数字($6.44),其他档位来自同一页面绘图所用的成本拆分数据。提取出的数值已和本文的调研文件一起保存。
| Neon 思考档位 | AA Intelligence Index | 单任务成本 | 输入占成本比例 | 每任务输出 token | 每任务耗时 |
|---|---|---|---|---|---|
low | 44.1 | $0.75 | 56% | ~21,700 | 3.7 分钟 |
medium | 54.9 | $1.90 | 61% | ~50,000 | 8.3 分钟 |
high(默认) | 59.6 | $3.74 | 64% | ~90,200 | 14.8 分钟 |
xhigh | 61.4 | $6.44 | 67% | ~141,600 | 21.5 分钟 |
来源:Artificial Analysis,2026-11-19 查看。这是第三方基准的平均值,不是 Google 的数据,也不是我们的实测。
从严格意义上读,这张表说明了几点:
- 从 low 到 xhigh,成本相差 8.6 倍,而单 token 价格不变。Neon 的预算一半看选哪个模型,另一半看思考档位。
- 从 high 升到 xhigh 是最贵的一步。 单任务成本增加约 72%($3.74 到 $6.44),耗时增加约 45%,换来 1.8 个指数点。Google 自己的建议与此一致:从
high开始,只在high解决不了的高难度多步问题上使用xhigh。 - 从 medium 升到 high,成本大约翻倍,换来 4.8 个指数点。如果你的任务在
medium就能通过,这笔节省是实打实的。 - low 便宜,但在这个指数上弱得多(44.1,
high为 59.6)。便宜的尝试如果失败,还得用更高档位重跑,两次的钱都要付。 - Agent 类工作中,输入占大头。 每个任务成本中有 56% 到 67% 来自输入。按 token 数算,输入的大部分是缓存命中;但按金额算,更大的一块是按 $3 全价计费的输入。Artificial Analysis 在
xhigh档的拆分显示:标为 “cache write” 的部分是 $2.59(即新的提示 token,Neon 按普通输入费率计费),缓存读取 $1.66,其他未缓存输入 $0.06。提示短、回答长的聊天应用情况会完全不同,那里占大头的是输出和思考。
最后一点也是这些数字的主要局限。Intelligence Index 混合了推理、知识和 Agent 任务,而你的工作负载有自己的输入输出比例、缓存命中率和验收标准。这张表适合用来看各档位之间的相对变化,具体成本还要测你自己的任务。
用同一套算法比较 Neon、Hydrogen 和 Carbon
只比较标价会得出误导性的结论,因为不同模型完成同一个任务消耗的 token 数不同。更公平的做法是取 Artificial Analysis 给出的各模型单任务 token 画像,再按 Google 当前费率重新计价。
这里有个细节很关键。Artificial Analysis 给 Carbon 用的是 $4/$20(12 月 1 日起生效的费率),给 Argon 用的却是 $2/$10(当前费率)。11 月 30 日之前,Google 对两者都按 $2/$10 收费。由于 Gemini 4 的每项 token 费率都是线性的,我们从 Artificial Analysis 的成本分项反推出 token 数,再分别按两个时段重新计价。测试套件会检查这种反推能否复现 Artificial Analysis 自己的总数。
| 模型和档位 | AA Index | 单任务成本(截至 11 月 30 日) | 单任务成本(12 月 1 日起) |
|---|---|---|---|
Neon low | 44.1 | $0.75 | $0.75 |
Neon medium | 54.9 | $1.90 | $1.90 |
Neon high | 59.6 | $3.74 | $3.74 |
Neon xhigh | 61.4 | $6.44 | $6.44 |
Hydrogen high | 50.8 | $1.87 | $1.87 |
Hydrogen xhigh | 53.9 | $3.16 | $3.16 |
Carbon low | 54.2 | $3.59 | $7.19 |
Carbon medium(默认) | 58.3 | $3.29 | $6.59 |
Carbon high | 60.0 | $3.88 | $7.76 |
Argon high | 50.4 | $4.97 | $9.95 |
token 画像:Artificial Analysis,2026-11-19。价格:Google Standard 费率。重新计价:我们的计算。
截至 11 月 30 日,Neon high 和 Carbon high 的单任务成本几乎相同($3.74 对 $3.88),指数得分也接近;Carbon 默认的 medium 档比 Neon high 略便宜。从 12 月 1 日起,Carbon 的单任务成本翻倍,Neon 不变,于是 Neon high 大约只有 Carbon high 一半的价格。Hydrogen xhigh 比 Neon high 便宜,但在这个指数上低 5.7 分。
Google 的 Neon 发布公告称,在 high 档,Neon “a 32% lower cost per task than Carbon”(单任务成本比 Carbon 低 32%)。我们无法用 Artificial Analysis 的当前数据复现 32%:按 12 月价格,Neon 比 Carbon high 低约 52%,比 Carbon medium 低约 43%;按 11 月价格,Neon 比 Carbon medium 还略贵一点。按 11 月价格和 Carbon high 比,Neon high 只便宜约 3.5%($3.74 对 $3.88)。两个价格时段里,没有哪个 Carbon 档位能得出 32%。Google 把这个数字和 Artificial Analysis Intelligence Index 挂钩,但没有说明用的是 Carbon 哪个思考档位、哪个价格时段、哪一版数据,而 Artificial Analysis 的数字在公告之后也可能有变化。请把 32% 当作 Google 的说法,而不是今天能重新算出来的数字。12 月调价的详细情况见我们的 Carbon 和 Argon 12 月调价指南;按任务选模型,见 Gemini 4 Neon 和 Carbon 对比。
一个可以自己重跑的小计算器
下面的计算器只用 Python 标准库和 Decimal,在你为显示而四舍五入之前,结果都是精确的。它接收的是你已经知道的 token 数(来自用量记录或明确的预测),而不是提示内容,也不会调用任何 API。
from decimal import Decimal as D
PER_M = D(1_000_000)
# USD per 1M tokens: (input, cached input, output incl. thinking). Checked 2026-11-19.
RATES = {
"gemini-4-neon/standard": ("3.00", "0.15", "15.00"),
"gemini-4-neon/batch": ("1.50", "0.075", "7.50"),
"gemini-4-neon/flex": ("1.50", "0.075", "7.50"),
"gemini-4-neon/priority": ("5.40", "0.27", "27.00"),
"gemini-4-hydrogen/standard": ("1.50", "0.075", "7.50"),
"gemini-4-carbon/standard@2026-11": ("2.00", "0.10", "10.00"),
"gemini-4-carbon/standard@2026-12": ("4.00", "0.20", "20.00"),
}
SEARCH_USD_PER_QUERY = D("14") / D("1000") # after the shared 5,000/month allowance
SEARCH_TIERS = {"standard", "priority"}
def rates(key):
if key not in RATES:
raise KeyError(f"no rate for {key!r}")
return tuple(D(x) for x in RATES[key])
def call_cost(key, input_tokens, cached_tokens, output_tokens):
"""input_tokens includes the cached subset; output_tokens includes thinking."""
for n in (input_tokens, cached_tokens, output_tokens):
if not isinstance(n, int) or n < 0:
raise ValueError("token counts must be non-negative integers")
if cached_tokens > input_tokens:
raise ValueError("cached_tokens is a subset of input_tokens")
r_in, r_cache, r_out = rates(key)
return ((input_tokens - cached_tokens) * r_in
+ cached_tokens * r_cache
+ output_tokens * r_out) / PER_M
def task_cost(key, calls, search_queries=0, free_searches_left=0):
"""calls: list of (input_tokens, cached_tokens, output_tokens)."""
if not calls:
raise ValueError("a task needs at least one call")
tokens = sum((call_cost(key, *c) for c in calls), D(0))
billable = max(0, search_queries - free_searches_left)
if billable and key.split("/")[1].split("@")[0] not in SEARCH_TIERS:
raise ValueError(f"no Search grounding price listed for {key}")
search = billable * SEARCH_USD_PER_QUERY
return {"tokens_usd": tokens, "search_usd": search, "total_usd": tokens + search}
print(task_cost("gemini-4-neon/standard", [(100_000, 80_000, 5_000)]))
# {'tokens_usd': Decimal('0.147'), 'search_usd': Decimal('0.000'), 'total_usd': Decimal('0.147')}
Carbon 的键名带有明确的时段,因为它的价格在 12 月 1 日变化,计算器不会替你猜是哪一个。它还会拒绝以下输入:缓存 token 多于总输入、负数或非整数的 token 数,以及空任务。账本为空并不能证明任务花费为零。
我们的完整版还加入了 Argon 费率、一个反推 token 数的函数(依据 Artificial Analysis 的成本拆分),以及包含 19 个测试的 unittest 套件。测试覆盖费率表(每个层级缓存都是输入的 5%,Batch 和 Flex 是 Standard 的一半,Priority 是 1.8 倍)、下面三个工作负载的精确总数、搜索免费额度的处理,以及上一节提到的重新计价检查。19 个测试全部离线通过。它们证明这套算术与 Google 公布的费率一致,但不能证明 Google 给你项目开的账单会与之吻合,后者取决于你如何整理用量记录。
三个计算示例
下面的 token 数是假设值,用来展示不同的成本结构,不是 Neon 的实测运行。每张表在所有模型上使用相同的 token 数,这样能单独看出费率的差别。真实任务在不同模型上消耗的 token 数不同,这正是上一节存在的原因。
1. 共享长前缀的编程 Agent
25 轮 Agent 调用,合计发送 1,500,000 个输入 token,其中 1,275,000 个命中隐式缓存(85%),产生 70,000 个输出 token(含思考)。
- 未缓存输入:225,000 × $3 / 1M = $0.675
- 缓存输入:1,275,000 × $0.15 / 1M = $0.191
- 输出:70,000 × $15 / 1M = $1.050
- Neon Standard 合计:$1.916
输出占账单的 55%,而它在 token 总数里还不到 5%。如果同一个任务需要 140,000 个输出 token(大致相当于在 Artificial Analysis 的任务上从 high 升到 xhigh 的变化),合计会升到 $2.97。
2. 针对同一份大文档反复提问
一份 400,000 token 的合同文件包。第一个问题没有缓存命中,产生 6,000 个输出 token。之后 19 个追问每次发送 402,000 token,其中 400,000 token 的文档前缀命中缓存,每次产生 3,000 个输出 token。
- 未缓存输入:400,000 + 19 × 2,000 = 438,000 token → $1.314
- 缓存输入:19 × 400,000 = 7,600,000 token → $1.140
- 输出:6,000 + 19 × 3,000 = 63,000 token → $0.945
- Neon Standard 合计:$3.399
如果完全没有缓存命中,同样 20 个问题要花 $25.06。在这类工作负载里,缓存决定了预算。
3. 带搜索 grounding 的调研简报
3 次调用,每次 20,000 个输入 token(无缓存命中)、4,000 个输出 token,另有 8 次 Google Search 查询(当月免费额度已用完)。
- 输入:60,000 × $3 / 1M = $0.180
- 输出:12,000 × $15 / 1M = $0.180
- 搜索:8 × $0.014 = $0.112
- Neon Standard 合计:$0.472
搜索占这个任务的 24%。搜索价格不随模型变化,所以模型越便宜,这笔费用的占比越明显。
同样的 token 数,四份价目表
| 工作负载 | Neon | Hydrogen | Carbon(截至 11 月 30 日) | Carbon(12 月 1 日起) |
|---|---|---|---|---|
| 编程 Agent | $1.916 | $0.958 | $1.278 | $2.555 |
| 文档问答 | $3.399 | $1.700 | $2.266 | $4.532 |
| 搜索调研简报 | $0.472 | $0.292 | $0.352 | $0.592 |
Hydrogen 的三项 token 费率正好是 Neon 的一半,所以 token 相同时它的成本也是一半。Carbon 在 11 月 30 日前是 Neon 的三分之二,12 月 1 日起是 Neon 的 4/3 倍。第三行里搜索那一项在每个模型上都是 $0.112,所以这一行不符合上述比例。这个计算不能告诉你哪个模型能通过你的验收测试,适配问题见 Gemini 4 选型指南。
Hydrogen 也是这几个模型中唯一有免费层级的,并且现在就能通过 Ofox 调用,模型 ID 为 google/gemini-4-hydrogen(模型页显示当前的 Ofox 价格)。
隐式缓存什么时候划算
Neon 的缓存费率比输入费率低 95%。能不能拿到这个价格,取决于 Google 缓存指南(英文)里的三条规则:
- 最小长度。 在 Neon 上,隐式缓存只适用于至少 4,096 token 的提示。3,000 token 的提示永远拿不到折扣。
- 前缀一致,时间相近。 命中来自重复的前缀。Google 建议把体积大、共享的内容(系统指令、工具定义、参考文档)放在开头,并在短时间内发送相似的请求。如果提示开头附近有时间戳或用户 ID,前缀就会被打断。
- 多轮对话和 Agent 循环的 2,050 token 规则。 在 Gemini 4 上,只有新请求比上一次请求至少多出 2,050 个 token(模型输出、思考和函数结果都算),上一次请求才会被完整缓存。新增内容更少时,上一次请求的最后 2,050 个 token 会按标准输入费率重新处理。Google 指出,大多数 Agent 轮次都会超过这个门槛。
满足条件不代表一定命中。请从响应里的 usage.total_cached_tokens 读取实际数量,把这个数字记进账本,而不是记你希望被缓存的前缀长度。由于没有显式缓存,也就没有存储费和缓存写入附加费:创建缓存的 token 按普通输入费率计费。
大前缀被多次复用时,缓存最划算,比如文档问答、带大量工具 schema 的 Agent,以及使用固定长指令的批量分类。对于一次性请求、短提示,或者每条消息开头都不一样的聊天,缓存作用不大。我们的缓存命中率计算指南按不同服务商分析了命中率变化对账单的影响。
选 Batch、Flex 还是 Priority?
把任务从 Standard 换到 Batch 或 Flex,token 成本减半:上面的编程 Agent 示例从 $1.916 降到 $0.958。代价在执行方式上,而不在价格上。Google 把 Batch 和 Flex 定位为离线评测、数据集处理和不紧急的 Agent 运行,把 Priority 定位为需要在高峰负载下保持稳定延迟的面向用户流量。
有两点实际提醒。第一,Batch 和 Flex 价格表没有列出 Google Search 价格,在这两个层级上跑带 grounding 的任务前,先查工具文档。第二,Priority 的 $5.40/$27.00 让 Neon 的单 token 价格比 Carbon Standard 还贵,即使和 12 月 1 日之后的 Carbon($4/$20)相比也是如此。只有在你实测确认 Standard 的延迟确实是问题时,才值得为 Priority 付费。
把 Neon 任务控制在预算内
max_output_tokens限制的是单次响应的思考加输出。 Neon 默认的同步上限是每个 hop(单段生成)65,536 token。它不是任务预算:输入、工具调用、重试和后续轮次都不受它限制。Google 建议降低思考档位,而不是把上限设得很低,因为上限太低可能截断回答,迫使你重试。- 长解码会抬高上限。 使用
background: true且max_output_tokens超过 65,536 时,服务器会按每段 64K 继续生成,最多到 1,048,576 减去你的输入,其中每个 token 都按输出计费。在 Standard 上,262,144 的上限仅输出部分最多就能花掉 $3.93,与思考档位无关。上限要按任务真正需要的量来设,而不是直接设成最大值。 - 选能通过验收的最低档位。 Google 自己的建议是:先用较高的
max_output_tokens在四个档位上都评测一遍,再选能达到质量标准的最低thinking_level。计算每个被接受任务的成本时,要把失败的尝试算进去。具体怎么测,见 Gemini 4 思考档位选择指南。 - 把报错当作记账问题来处理。 超时并不能证明服务器没有做任何工作,缺少 usage 字段也不能证明成本为零。我们的 Gemini 4 API 报错指南(示例用的是 Argon,Gemini 4 API 相同)可以帮你在重试前区分配额、参数和临时性故障。Carbon、Neon 和 Hydrogen 特有的症状见 Gemini 4 Carbon、Neon、Hydrogen 报错排查。重试设计的通用做法见 Ofox 的错误处理指南。
如果需要一套完整的逐次尝试账本格式,以及重试和续接的边界情况,Carbon 任务成本指南对同一套 Gemini 4 计费模式讲得更深入;Argon 价格指南提供了月度预算表。
在哪里可以调用 Neon
截至 2026 年 11 月 19 日,Neon 可以在 Google Gemini API 的付费层级上使用(generateContent 和 Interactions API 都支持),也可以在 Google AI Studio 中通过 Google AI Pro 和 Ultra 方案使用。它不在 Ofox 的模型列表里,所以无法通过 Ofox 调用,本文也没有 Ofox 的 Neon 价格。如果要用 Google 自己的 SDK 发起请求,见我们的 Gemini 4 Neon API 指南。
如果你现在就想通过 Ofox 使用 Gemini 4 模型,可用的 ID 是 google/gemini-4-hydrogen 和 google/gemini-4-argon。Ofox Gemini API 参考给出了请求格式,各模型页列出了当前价格。


