Nano Banana Pro Batch API 成本：2K 用 Batch，4K 按次 $0.09 更省

截至 2026 年 10 月 4 日，Nano Banana Pro（模型 ID gemini-3-pro-image）走 Google Batch 时，1K 和 2K 图片输出每张 $0.067，4K 每张 $0.12，正好是 Standard（$0.134 / $0.24）的一半（Google 价格页）。这只是图片输出部分，提示词、参考图和思考 token 另外计费。

结论按尺寸分开看：

• 1K/2K、能等 24 小时：Google Batch 最便宜。按 200 个提示词 token、1,000 个思考 token 估算，每张约 $0.0732。
• 4K：按次计费 $0.09 的网关比 Google Batch 便宜，因为 Batch 光是 4K 图片输出就要 $0.12。
• 必须马上出图：Standard 每张 $0.134 起，同样比 $0.09 的按次路线贵；Flex 有标价，但 Google 的 Flex 支持列表里没有这个模型，要先测一次请求。
• 混合几条路线：混合均价 = Σ（占比 × 该路线单价），结果一定落在用到的最便宜和最贵的单价之间。低于最便宜那条路线的「混合均价」一定算错了。

下面每个数字都给出公式和输入，可以代入自己的任务重算；文末有一个测试过的离线计算脚本。

Nano Banana Pro 每张多少钱：Standard、Batch、Flex 与按次 $0.09

Google 对 Nano Banana Pro 的图片输出按 token 计价：1K 和 2K 图每张 1,120 个 token，4K 每张 2,000 个 token。Standard 的图片输出单价是每 100 万 token $120，所以 1K/2K 每张 $0.134、4K 每张 $0.24；Batch 减半为每 100 万 token $60，即每张 $0.067 和 $0.12。Nano Banana Pro 只有 1K、2K、4K 三档，没有 0.5K。

表中 Google 的数字均截至 2026 年 10 月 4 日，来自 Gemini Developer API 价格页；Vertex AI（Global）的 Gemini 3 Pro Image 采用相同费率，Standard 为输入 $2、文本输出 $12、图片输出 $120（每 100 万 token），Flex/Batch 为 $1 / $6 / $60（Vertex AI 价格页）。Priority 每张价格按 1,120 × $216 ÷ 1,000,000 ≈ $0.242、2,000 × $216 ÷ 1,000,000 = $0.432 换算，只作对照。

按次网关的价格是 laozhang.ai 截至 2026 年 9 月 24 日的公开价：gemini-3-pro-image 不论 1K、2K、4K 或思考多少，每次调用 $0.09（laozhang.ai 文档）。这是服务商自己的价格和规则，大批量开工前以文档页当天显示为准。各层级的完整价格表见 Google 官方各层级每张价格；订阅与 API 的整体比较见 Nano Banana Pro 多少钱？API、订阅与每张合格图成本。

模型 ID 要用 gemini-3-pro-image。预览版 gemini-3-pro-image-preview 已于 2026 年 6 月 25 日停用（Google 弃用页），旧代码和旧教程里还用这个 ID 的，提交批量作业前先改掉。

一张图的实际费用：图片输出之外的提示词、参考图和思考 token

每张图的账单不止图片输出那一项。Google 路线（Standard、Batch、Flex）的单次费用可以这样算：

单次费用 = 图片输出单价
         + 提示词 token × 输入单价
         + 参考图张数 × 每张参考图单价
         + （思考 token + 文本输出 token）× 文本输出单价

思考 token 和图片输出 token 的单价不同，不能合并成一个数算。Gemini 3 的图片模型始终开启思考，思考 token 按文本输出单价计费。

示例假设：提示词 200 个 token、没有参考图、思考 1,000 个 token。

• Batch 2K：$0.067 + 200 × $1 ÷ 1,000,000 + 1,000 × $6 ÷ 1,000,000 = $0.067 + $0.0002 + $0.006 = $0.0732
• Batch 4K：$0.12 + $0.0002 + $0.006 = $0.1262
• Standard 2K：$0.134 + $0.0004 + $0.012 = $0.1464
• Standard 4K：$0.24 + $0.0004 + $0.012 = $0.2524

如果每次再带 2 张参考图，Batch 2K 加 2 × $0.0006 = $0.0012，变成 $0.0744；Standard 2K 加 2 × $0.0011 = $0.0022，变成 $0.1486。

1,000 个思考 token 只是假设。实际数量要看你自己请求返回的 usageMetadata：promptTokenCount 是输入，thoughtsTokenCount 是思考，candidatesTokensDetails 按模态列出输出（图片和文本分开）。先用 Standard 或小批量 Batch 跑 20～50 张有代表性的提示词，取平均值再代入公式，比任何默认值都准。

Batch 和按次 $0.09 哪个便宜：1K/2K 看思考 token，4K 按次更低

4K 的答案不用算思考 token：Google Batch 光是 4K 图片输出就要 $0.12，已经高于每次 $0.09。Standard 在任何尺寸下也都高于 $0.09。

1K/2K 才需要算盈亏平衡点。Batch 的图片输出 $0.067 比 $0.09 低 $0.023，只要额外计费的 token 不超过这个差额，Batch 就更便宜：

盈亏平衡的思考与文本输出 token =（$0.09 − $0.067 − 提示词费用 − 参考图费用）÷（$6 ÷ 1,000,000）

• 提示词 200 个 token、无参考图：（0.09 − 0.067 − 0.0002）÷ 0.000006 = 约 3,800 个 token
• 提示词 200 个 token、2 张参考图：（0.09 − 0.067 − 0.0002 − 0.0012）÷ 0.000006 = 约 3,600 个 token

也就是说，1K/2K 任务每张平均思考加文本输出在 3,600～3,800 个 token 以下时，Batch 更便宜；超过时，$0.09 的按次路线反而更省。这个阈值只比较价格，以下几个差别会改变实际选择：

• 失败怎么计费：laozhang.ai 的规则是 HTTP 200 但没有图片也算一次调用；客户端超时后服务端仍可能完成并计费，重试前先查调用日志；在生成前就被 429/503 拒绝的请求通常不计费。Google Batch 里单行失败是否计费，公开文档没有写。
• 尺寸与比例：在 laozhang.ai 上，只有 Gemini 原生的 generateContent 路线能设置尺寸和比例；OpenAI 兼容路线固定返回 1K、1:1。要 4K 必须走原生路线。
• 等待时间：Batch 最长按 24 小时计划，按次网关是同步返回。
• 批量折扣：laozhang.ai 文档里没有批处理或折扣档，$0.09 就是大批量时的单价。

网关和 Google 直连在稳定性、交付方式上的差别，见 Nano Banana API 稳定路线：Google 直连、laozhang.ai 网关还是双路线。

混合均价怎么算：只能落在最便宜和最贵的路线之间

一批任务分几条路线跑时，每张的平均成本是加权平均：

混合均价 = Σ（路线 i 的占比 × 路线 i 的每张单价），所有占比相加 = 1

加权平均有一个可以直接用来检查的性质：结果一定落在所用路线中最便宜和最贵的单价之间。拿 $0.067 和 $0.09 混合，不管比例怎么调，均价都在 $0.067 到 $0.09 之间；拿 4K 的 $0.12 和 $0.09 混合，均价不可能低于 $0.09。

示例：2K 任务 70% 走 Batch、30% 走 $0.09 的按次路线。

• 只算图片输出：0.7 × $0.067 + 0.3 × $0.09 = $0.0469 + $0.027 = $0.0739
• 计入默认 token 假设（Batch 每张 $0.0732）：0.7 × $0.0732 + 0.3 × $0.09 = $0.05124 + $0.027 = 约 $0.0782

两个结果都在各自两项单价之间，可以作为检查别人报价的模板。看到一个「混合均价」时，依次核对：

1. 各路线占比加起来是不是 100%。
2. 每条路线的单价是不是同一个模型、同一个尺寸的当前价格。
3. 均价是否落在最低和最高单价之间。
4. 是否说明了有没有算提示词、参考图和思考 token。

第 2 条最容易出错。$0.022 是 Nano Banana 2 在 0.5K 尺寸的 Batch 价，不是 Nano Banana Pro 的价格，Pro 也没有 0.5K 档。把它和 Pro 的单价放在一起加权，算出来的不再是 Pro 的成本，而是换了模型。

每张可用图成本：返工率 20% 时 $0.067 变成约 $0.084

批量出图时总有一部分结果不能用：构图不对、文字错了、商品细节走样。只要这些图已经生成并计费，每张可用图的成本就是：

每张可用图成本 = 每次尝试成本 ÷（1 − 返工率）

以 Batch 2K 只算图片输出为例，返工率 20% 时：$0.067 ÷ 0.8 = $0.08375，已经接近 $0.09。如果按次路线的返工率明显更低，或者 Batch 的提示词要多跑几轮才能定稿，结论可能反过来。返工率要用你自己的验收结果统计，不同类目、不同提示词之间差别很大。

这里的返工率指已经出图、但不合格的结果。没有图片的结果是另一回事：Google Batch 里失败行是否计费没有公开说明，laozhang.ai 对 200 但没出图的调用按一次收费。结果里没有图片时，按 Nano Banana API 不出图：按返回字段逐项排查 逐项查。

一万张图的月账单：2K 与 4K 各路线对比

按每月 10,000 张、每次一张图计算，先只看图片输出：

再计入默认 token 假设（提示词 200、思考 1,000、无参考图）：

2K 时 Batch 比按次路线每月少 $168（$900 − $732）；4K 时按次路线比 Batch 少 $362（$1,262 − $900）。如果 2K 任务里有 30% 必须当天交付、改走按次路线：7,000 × $0.0732 + 3,000 × $0.09 = $512.40 + $270 = $782.40，平均每张约 $0.0782，与上一节的加权平均一致。

这些表都没有算返工。返工率 r 时，把表中每个数除以（1 − r）。

任务怎么拆：哪些必须同步出图，哪些可以交给 Batch

拆分的依据是交付时间和尺寸，不是任务量本身：

几个具体做法：

• 商品图、数据集、广告变体这类可以提前排期的任务，按 1K/2K 交给 Batch；其中 4K 的部分单独拆出来，按次计费更省。
• 当天上线的少量图不要等 Batch。Batch 的目标是 24 小时内完成，多数时候更快，但没有更短的承诺。
• Flex 是同步的「尽力而为」层级，不是批处理：请求里设 service_tier: "flex"，延迟目标是 1–15 分钟，容量不足时返回 503，限流时返回 429（Flex 文档）。价格页列了 gemini-3-pro-image 的 Flex 价格，但同一套文档的 Flex 支持模型列表里只有 Gemini 文本模型，所以先发一次请求确认能用，再决定是否把任务交给它。遇到 429 或 503 时，按 Nano Banana API 报错：先分清 429、503、无图像和请求被拒 处理。
• Nano Banana 2（gemini-3.1-flash-image）的 Batch 价是 0.5K $0.022、1K $0.034、2K $0.050、4K $0.076，Standard 是 $0.045、$0.067、$0.101、$0.151。它比 Pro 便宜，但它是另一个模型，适不适合要看你的验收标准，不能和 Pro 的单价混在一起算均价。

Batch 的运营代价：24 小时、48 小时过期、按行状态与 6 周保存

Batch 省下的一半费用，是用等待时间和更多作业管理工作换来的。按 Google 的 Batch API 文档（2026 年 9 月 17 日更新），影响成本和风险的有这几条：

• 等待：目标是 24 小时内完成，多数情况下快得多。对 Nano Banana 来说，Batch 用最长 24 小时的周转换取更高的速率限制。
• 过期：作业处于排队或运行状态超过 48 小时会变成 JOB_STATE_EXPIRED，这个作业没有任何结果可取。交付时间要按「可能完全拿不到」来留余量，不能只按 24 小时排期。
• 按行返回：大批量图片推荐用 JSONL 文件提交（文件上限 2 GB；20 MB 以下也可以直接内联请求）。每行带一个你自己定的 key，结果文件的每一行要么是生成结果，要么是一个状态对象，用同一个 key 对应回去。作业状态是 SUCCEEDED 不代表每一行都出了图。
• 失败行计费：作业成功但其中某些行失败时，这些行是否计费，取消作业时已经处理的部分怎么计费，文档都没有写。取消只会「停止处理新的请求」。
• 结果保存 6 周：结果默认保存 6 周后永久删除，作业完成后尽快下载归档。
• 通知：可以订阅 batch.succeeded 等 webhook 事件，不必一直轮询。
• 缓存：Batch 请求支持上下文缓存，大量请求共用很长的系统说明或参考资料时可以考虑。
• 接口范围：Batch 只能通过 generateContent 这一套接口使用，Interactions API 里没有 Batch。

JSONL 每一行的结构如下。这是按 Google Batch 文档里图片示例的结构写的，模型换成当前的 gemini-3-pro-image，imageConfig.imageSize 取自 generateContent 的接口参考：

{"key": "sku-0001", "request": {"contents": [{"parts": [{"text": "白色背景上的陶瓷咖啡杯商品图，柔和自然光"}]}], "generation_config": {"responseModalities": ["TEXT", "IMAGE"], "imageConfig": {"imageSize": "2K"}}}}

提交时把这个文件上传后，用 client.batches.create(model="gemini-3-pro-image", src=上传后的文件名) 创建作业。单次请求的写法和参数说明见 Nano Banana Pro API 怎么调用：官方文档、JSON 模板、YAML 配置与 PDF 边界。

失败行是否计费没有公开说明，就用数据自己核对：作业结束后统计结果文件里出图、没出图、报错的行数，以及各行 usageMetadata 的 token 合计，再和 Google Cloud 账单报表里同一时段的费用对照。下面这段脚本做的是第一步：

import json
import sys

totals = {"lines": 0, "images": 0, "no_image": 0, "errors": 0,
          "prompt": 0, "thoughts": 0, "candidates": 0}
with open(sys.argv[1], encoding="utf-8") as f:
    for line in f:
        if not line.strip():
            continue
        row = json.loads(line)
        totals["lines"] += 1
        resp = row.get("response")
        if not resp:                      # 状态对象：这一行没有生成结果
            totals["errors"] += 1
            continue
        parts = (resp.get("candidates") or [{}])[0].get("content", {}).get("parts", [])
        if any("inlineData" in p for p in parts):
            totals["images"] += 1
        else:
            totals["no_image"] += 1       # 有响应但没有图片
        usage = resp.get("usageMetadata", {})
        totals["prompt"] += usage.get("promptTokenCount", 0)
        totals["thoughts"] += usage.get("thoughtsTokenCount", 0)
        totals["candidates"] += usage.get("candidatesTokenCount", 0)
print(json.dumps(totals, indent=1))

运行方式：python3 tally_results.py batch_results.jsonl。这段脚本只用按文档格式手写的 4 行样例（1 行出图、2 行无图、1 行报错）测试过，统计结果正确；没有在真实的 Batch 结果文件上跑过，字段如有出入按实际结果调整。如果账单金额明显高于「出图行数 × 单价 + token 费用」，多出来的部分就要按失败行也计费来估算下一批的预算。

离线成本计算脚本：代入单价、token 和返工率

下面的 Python 脚本把前面几节的公式写在一起，不依赖第三方库，也不调用任何 API。它是估算器，不是账单：单价写死在 RATES 里，价格变动时要手动更新。

"""估算一批 Nano Banana Pro（gemini-3-pro-image）任务在不同路线下的费用。

单价取自 Google 截至 2026-10-04 公布的美元价格，外加一个按次计费网关的单价；
价格变动时修改 RATES。
"""

RATES = {
    # 图片输出按尺寸计每张价格；文本/思考输出与输入按每 100 万 token 计价
    "standard": {"image": {"1K": 0.134, "2K": 0.134, "4K": 0.24},
                 "text_out_per_m": 12.00, "input_per_m": 2.00, "ref_image": 0.0011},
    "batch":    {"image": {"1K": 0.067, "2K": 0.067, "4K": 0.12},
                 "text_out_per_m": 6.00, "input_per_m": 1.00, "ref_image": 0.0006},
    # 按次计费路线：不论尺寸和思考 token，每次调用一个价
    "per_call": {"flat": 0.09},
}


def cost_per_call(route, size, prompt_tokens=200, thinking_tokens=1000, ref_images=0):
    r = RATES[route]
    if "flat" in r:
        return r["flat"]
    return (r["image"][size]
            + prompt_tokens * r["input_per_m"] / 1_000_000
            + ref_images * r["ref_image"]
            + thinking_tokens * r["text_out_per_m"] / 1_000_000)


def cost_per_usable_image(call_cost, reject_rate):
    """每次尝试都计费；其中 reject_rate 比例的结果不能用。"""
    if not 0 <= reject_rate < 1:
        raise ValueError("reject_rate must be in [0, 1)")
    return call_cost / (1 - reject_rate)


def blended(shares_and_costs):
    """shares_and_costs：(占比, 单价) 列表；占比之和必须为 1。"""
    total_share = sum(s for s, _ in shares_and_costs)
    if abs(total_share - 1) > 1e-9:
        raise ValueError("shares must add up to 1")
    return sum(s * c for s, c in shares_and_costs)


if __name__ == "__main__":
    images, size = 10_000, "2K"
    for route in ("standard", "batch", "per_call"):
        c = cost_per_call(route, size)
        print(f"{route:9s} {size}: 每次 ${c:.4f}，{images:,} 张合计 ${c * images:,.2f}")
    mix = blended([(0.7, cost_per_call("batch", size)), (0.3, cost_per_call("per_call", size))])
    print(f"70% batch + 30% per_call：每张 ${mix:.4f}")

直接运行 python3 batch_cost.py 的输出：

standard  2K: 每次 $0.1464，10,000 张合计 $1,464.00
batch     2K: 每次 $0.0732，10,000 张合计 $732.00
per_call  2K: 每次 $0.0900，10,000 张合计 $900.00
70% batch + 30% per_call：每张 $0.0782

截至 2026 年 10 月 4 日，这个脚本在 Python 3.12.1 下通过了 12 项检查：前文的单次费用（$0.0732、$0.1262、$0.1464）、加权平均 $0.0739、返工率 20% 的 $0.08375、约 3,800 个 token 的盈亏平衡点、1,000 组随机比例的混合均价都落在两项单价之间，以及占比之和不为 1、返工率为 100% 时会报错。

用法举例：把你实测的平均思考 token 填进 cost_per_call("batch", "2K", thinking_tokens=…)，把验收得到的返工率填进 cost_per_usable_image，再用 blended 按实际拆分比例求均价。三步得出的就是这批任务每张可用图的预算。

常见问题

Nano Banana Pro API 的价格是多少？

截至 2026 年 10 月 4 日，Google Standard 每张 1K/2K 图 $0.134、4K $0.24；Batch 每张 $0.067 和 $0.12；提示词、参考图和思考 token 另计。laozhang.ai 按次计费，不分尺寸每次 $0.09。订阅版和 API 的完整对比见 Nano Banana Pro 多少钱？API、订阅与每张合格图成本。

Nano Banana Pro 的 Batch API 有免费额度吗？

没有。Google 价格页上 Nano Banana Pro 的 Standard、Batch、Flex 都标注免费层「不可用」，图片生成从第一张开始按付费价计费。

Nano Banana Pro 的 Batch 作业要等多久？

Google 的目标是 24 小时内完成，文档说多数情况下快得多，但不承诺更短的时间。排队或运行超过 48 小时的作业会过期，且没有结果可取，所以有截止时间的任务要留出余量，或者改走同步路线。

Nano Banana Pro 有 0.5K 尺寸吗？每张 $0.022 是哪个模型？

Nano Banana Pro 只有 1K、2K、4K 三档。每张 $0.022 是 Nano Banana 2（gemini-3.1-flash-image）0.5K 尺寸的 Batch 价，不能用来估算 Pro 的成本。

Flex 能用来跑 Nano Banana Pro 吗？

价格页列出了 Nano Banana Pro 的 Flex 价格（与 Batch 相同），但 Flex 文档的支持模型列表里没有它。在请求里设 service_tier: "flex" 发一次测试，确认能返回图片再用；它是同步的尽力而为层级，容量不足时会返回 503。