Цены Nano Banana, GPT Image 2 и FLUX.2 Pro API: сравнение

Nano Banana 2 через API429 стоит от $0,0201 за выходное изображение 1K. В опубликованном стандартном тарифе Google такое изображение стоит около $0,067. Для 10 000 генераций это $201 против примерно $670 — без стоимости входных токенов и дополнительных операций.

Мы сверили цены API429, Google, OpenRouter, Replicate, fal и Black Forest Labs на 23 сентября 2026 года. Для Nano Banana 2 API429 дешевле всех сопоставленных предложений с одинаковым разрешением в таблице. У GPT Image 2 результат зависит от размера и качества: например, по опубликованным условиям Replicate выгоднее для High 2K.

Сравнение подготовила команда API429 — одного из участвующих сервисов. Ниже приведены первичные источники и условия расчёта, чтобы вы могли самостоятельно проверить цифры. Это сравнение публичных тарифов, а не тест качества, скорости или фактических списаний.

Для своего объёма откройте калькулятор бюджета Nano Banana API: он учитывает выбранный режим и предполагаемую долю принятых изображений. Это оценка стоимости выходных изображений; входные токены и другие операции оплачиваются дополнительно.

Как сравнивать стоимость генерации изображений через API

Цена имеет смысл только вместе с точным названием модели, размером результата и режимом качества. Nano Banana 2 и Nano Banana Pro — разные модели; у GPT Image 2 режимы Low, Medium и High тоже оплачиваются по-разному. Минимальную цену Low нельзя напрямую сопоставлять с High другого сервиса.

Во всех таблицах указаны доллары США за одно выходное изображение. Не включены входные тексты и референсы, дополнительный текстовый ответ, thinking, поиск, налоги и комиссии пополнения. Бонусы крупных пополнений и индивидуальные договоры также не включены. Полная стоимость запроса может быть выше цены изображения.

Наши ставки взяты из публичного каталога API429. Текущие модели и условия подключения доступны в каталоге моделей и документации API429.

Nano Banana 2: API429, Google, OpenRouter, Replicate и fal

Nano Banana 2 соответствует модели gemini-3.1-flash-image. Для квадратных изображений сравниваем 1K, 2K и 4K: 1024×1024, 2048×2048 и 4096×4096 соответственно.

Источники: Google Gemini API, OpenRouter Nano Banana 2, Replicate Nano Banana 2 и fal Nano Banana 2.

¹ Для OpenRouter сумма рассчитана по публичной ставке $60 за миллион выходных image-токенов и 1120/1680/2520 токенам на изображение соответствующего размера. Google публикует округлённые эквиваленты. Поэтому небольшие различия в таблице не означают отдельную наценку OpenRouter. Дополнительные токены и операции оплачиваются отдельно; конкретный маршрут может иметь свои условия.

По этим опубликованным ставкам выходное изображение в API429 примерно на 70% дешевле Google Standard. Kie исключён из построчного сравнения: текущая публичная страница подтверждает стартовую цену от $0,04, но не даёт достаточно данных для проверки одинаковых условий 1K, 2K и 4K.

Сколько стоят 10 000 изображений Nano Banana 2

Допустим, нужно получить 10 000 квадратных изображений в 1K: варианты предметной съёмки, иллюстрации для каталога или материалы для разных рекламных форматов. При одном выходном изображении на генерацию стоимость только изображений будет такой:

Для Google Standard точный токенный расчёт даёт $672, а для Batch — $336. Округлённые эквиваленты на странице Google дают около $670 и $340 соответственно. В бюджете большой партии полезно сохранять точность до последнего шага расчёта.

Google Batch — отдельный режим обработки. Его нельзя считать эквивалентом интерактивной генерации по времени ожидания. В этом примере ставка API429 ниже и Batch примерно на 40%, но таблица не сравнивает сроки выполнения или доступную параллельность. Источник ставок и токенизации: официальные тарифы Google.

Массовая генерация также не означает, что все результаты подойдут с первой попытки. Если часть изображений нужно переделать, бюджет растёт. Полезная метрика для проекта — общая стоимость генераций, делённая на число принятых изображений. Она учитывает отбор и повторы, а не только минимальную цену успешного ответа.

О форматах запросов и работе с моделями этой семьи читайте на странице Nano Banana API.

Nano Banana Pro: цены на 1K, 2K и 4K

Nano Banana Pro соответствует gemini-3-pro-image. У этой модели 1K и 2K имеют одинаковую ставку выходного изображения, а 4K оплачивается отдельно.

Источники: Google, каталог OpenRouter, Replicate Nano Banana Pro, fal Nano Banana Pro.

Здесь API429 также ниже всех сопоставленных ставок. Относительно опубликованных Google Standard эквивалентов экономия на выходном изображении составляет 70%. Для OpenRouter расчёт использует $120 за миллион выходных image-токенов: 1120 токенов для 1K–2K и 2000 для 4K.

GPT Image 2: когда API429 дешевле Replicate

Для GPT Image 2 одного разрешения недостаточно: нужно зафиксировать quality. Мы сопоставили квадратные размеры и одинаковые значения Low, Medium и High.

Источники: каталог API429 и GPT Image 2 на Replicate.

Replicate указывает цену по качеству без отдельной надбавки за размер и позволяет выбрать 2048×2048. Поэтому по опубликованным условиям он дешевле в строке High 2K. Итоговое списание для этого режима мы платным запросом не проверяли. У API429 выбор Auto тарифицируется как High.

FLUX.2 Pro: цена API и бюджет на массовую генерацию

FLUX.2 Pro в API429 доступен под ID FLUX.2-pro. Для генерации по тексту без входных изображений стандартный каталог публикует следующие ставки; проверка — 23 сентября 2026 года.

В тарифе API429 1 МП соответствует 1024 × 1024 пикселям. 2 МП не равны квадратному изображению 2K: 2048 × 2048 — это 4 МП. Условия таблицы: одно выходное изображение, reference_mp=0. Редактирование с референсами требует другого расчёта.

У Black Forest Labs FLUX.2 Pro начинается от $0,03 за изображение; цена зависит от разрешения. Сопоставление базового текстового режима 1 МП даёт $90 за 10 000 изображений у API429 против $300 по базовой ставке BFL. Разница — $210, или 70%, при указанных условиях. Это расчёт тарифов, а не результат платного сравнительного теста.

Для крупных размеров используйте калькулятор выбранного провайдера: минимальная ставка «от $0,03» не является ценой любого разрешения. Скидку на один режим нельзя переносить на весь рынок, редактирование или другие модели FLUX.

Источники: публичный каталог API429, официальные тарифы Black Forest Labs. Порядок запуска партии и сохранения результатов — в гайде массовой генерации изображений через API.

Рабочая формула: стоимость принятого результата

Для сопоставимого расчёта запишите пять значений: цену выходного изображения, дополнительные входные операции, число всех попыток, число принятых результатов и комиссии пополнения. Затем используйте формулу:

(стоимость всех попыток + входные операции + комиссии) / число принятых результатов.

Например, 10 000 принятых изображений при 12 000 оплаченных попыток в Nano Banana 2 1K через API429 дают $241,20 только за выходные изображения: 12 000 × $0,0201. Это расчёт по тарифу, а не измеренное списание. Если есть референсы, текстовый вывод, поиск или комиссия, добавьте их отдельно. Такая таблица не смешивает минимальную цену успешного ответа с реальной стоимостью принятого результата.

Как выбрать API для массовой генерации

Начните с режима, который нужен вашему продукту. Если итоговое изображение используется в небольшом превью, отдельно оцените, оправданы ли 4K и самый дорогой режим качества. Если нужны мелкие надписи или последующее кадрирование, проверьте это на собственных примерах: таблица цен сама по себе не определяет подходящий размер.

Перед запуском партии зафиксируйте:

• точный идентификатор модели, разрешение и качество;
• количество выходных изображений и входных референсов;
• необходимость поиска, дополнительного текста и других платных операций;
• бюджет повторов и критерии приёмки;
• доступность модели для вашего ключа, ограничения параллельности и поведение при ошибках.

Сначала измерьте стоимость небольшой серии на одинаковых заданиях. Сохраняйте параметры, фактическую сумму списания, время выполнения и число принятых результатов. Так можно сравнить стоимость пригодного изображения без предположения, что одинаковое название модели гарантирует одинаковый опыт работы со шлюзом.

Для подключения нескольких семейств моделей через единый интерфейс используйте руководство по OpenAI-совместимому шлюзу. Возможности Google-направления и ограничения совместимости описаны на странице Vertex AI API.

Практический запуск партии описан в гайде массовой генерации изображений через API: очередь на Python, сохранение результатов и действия после таймаута.

Частые вопросы о ценах

API429 дешевле всех API для изображений?

Для Nano Banana 2 API429 дешевле всех сопоставленных публичных предложений в этой статье на дату проверки. Это не утверждение обо всём рынке, индивидуальных тарифах или каждой модели. Для GPT Image 2 High 2K в таблице есть более дешёвое предложение Replicate.

Цена изображения равна полной стоимости запроса?

Не обязательно. Входные токены, референсы, текстовый ответ, thinking и поиск могут оплачиваться отдельно. Для полного бюджета учитывайте эти операции, условия пополнения и повторные генерации.

Сравнение распространяется на FLUX и видео?

FLUX.2 Pro разобран в отдельной таблице выше: указаны размер выхода и отсутствие референсов. Видео в расчёт не включено — для него нужно отдельно зафиксировать модель, разрешение, длительность и наличие звука.

Где проверить цену перед запуском?

Посмотрите актуальный каталог API429 и страницы тарифов выбранных сервисов. Таблицы Nano Banana, GPT Image 2 и FLUX.2 Pro проверены 23 сентября 2026 года; перед большой партией стоит заново проверить ставки и фактические списания на небольшой серии.

Подробные тарифы по семействам моделей

Отдельные сравнения с живыми ценами API429: Nano Banana 2, Lite и Pro, GPT Image 2 и 2.5 и FLUX.2 Pro. В них сохранены единицы оплаты, условия размеров и дата проверки внешних источников. Общая методика сравнения семейств приведена в этой статье.

Автономный расчёт бюджета партии изображений на Python 3.10+

Перед выбором модели для серийной генерации сверьте актуальные параметры первого запроса на хабе генерации изображений API429 и страницы подключения по провайдерам: Google, OpenAI и Black Forest Labs. У каждого семейства свои единицы тарификации: фиксированная цена выходного изображения по уровню разрешения (1K, 2K, 4K) у Nano Banana 2 (gemini-3.1-flash-image), ступени качества (low, medium, high) на квадрате 1024x1024 плюс отдельные входные текстовые токены у GPT Image 2 (gpt-image-2), а также формула по выходным мегапикселям у FLUX.2 Pro (FLUX.2-pro), где 1 MP = 1 048 576 пикселей.

Приведённый ниже самодостаточный скрипт на стандартной библиотеке Python 3.10+ рассчитывает и сопоставляет детерминированный бюджет партии с учётом доли принятых изображений (acceptance_rate) по тарифам API429: gemini-3.1-flash-image ($0.0201 за 1K, $0.0303 за 2K, $0.0453 за 4K), gpt-image-2 ($0.0018 low / $0.0159 medium / $0.0633 high при 1024x1024 плюс $1.50 за 1M входных токенов) и FLUX.2-pro ($0.0090 за первый выходной мегапиксель + $0.0045 за каждый дополнительный мегапиксель без референсов при 1 MP = 1 048 576 пикселей):

from __future__ import annotations

from dataclasses import dataclass
from decimal import Decimal, ROUND_HALF_UP
import json
import math
from typing import Literal

NanoResolution = Literal["1K", "2K", "4K"]
GptQuality = Literal["low", "medium", "high"]

NANO_BANANA_2_RATES_USD: dict[NanoResolution, Decimal] = {
    "1K": Decimal("0.0201"),
    "2K": Decimal("0.0303"),
    "4K": Decimal("0.0453"),
}

GPT_IMAGE_2_1024_RATES_USD: dict[GptQuality, Decimal] = {
    "low": Decimal("0.0018"),
    "medium": Decimal("0.0159"),
    "high": Decimal("0.0633"),
}

FLUX_2_PRO_FIRST_MP_USD = Decimal("0.0090")
FLUX_2_PRO_EXTRA_MP_USD = Decimal("0.0045")
ONE_MEGAPIXEL_PIXELS = 1_048_576


@dataclass(frozen=True)
class BatchEstimate:
    model: str
    mode: str
    accepted_target: int
    total_attempts: int
    per_attempt_usd: Decimal
    total_batch_usd: Decimal
    effective_accepted_usd: Decimal


def required_attempts(accepted_target: int, acceptance_rate: float) -> int:
    if accepted_target < 1 or not (0.0 < acceptance_rate <= 1.0):
        raise ValueError("Invalid batch target or acceptance rate")
    return math.ceil(accepted_target / acceptance_rate)


def budget_nano_banana_2(
    accepted_target: int,
    resolution: NanoResolution,
    acceptance_rate: float = 1.0,
) -> BatchEstimate:
    attempts = required_attempts(accepted_target, acceptance_rate)
    per_image = NANO_BANANA_2_RATES_USD[resolution]
    total = (per_image * Decimal(attempts)).quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
    effective = (total / Decimal(accepted_target)).quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
    return BatchEstimate(
        model="gemini-3.1-flash-image",
        mode=f"resolution={resolution}",
        accepted_target=accepted_target,
        total_attempts=attempts,
        per_attempt_usd=per_image,
        total_batch_usd=total,
        effective_accepted_usd=effective,
    )


def budget_gpt_image_2(
    accepted_target: int,
    quality: GptQuality,
    input_tokens: int = 0,
    input_per_1m_usd: Decimal = Decimal("1.50"),
    acceptance_rate: float = 1.0,
) -> BatchEstimate:
    attempts = required_attempts(accepted_target, acceptance_rate)
    output_image_usd = GPT_IMAGE_2_1024_RATES_USD[quality]
    input_tokens_usd = (Decimal(input_tokens) * input_per_1m_usd) / Decimal(1_000_000)
    per_attempt = output_image_usd + input_tokens_usd
    total = (per_attempt * Decimal(attempts)).quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
    effective = (total / Decimal(accepted_target)).quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
    return BatchEstimate(
        model="gpt-image-2",
        mode=f"1024x1024:{quality}",
        accepted_target=accepted_target,
        total_attempts=attempts,
        per_attempt_usd=per_attempt.quantize(Decimal("0.000001"), rounding=ROUND_HALF_UP),
        total_batch_usd=total,
        effective_accepted_usd=effective,
    )


def flux_2_pro_output_megapixels(width: int, height: int) -> int:
    if width < 1 or height < 1:
        raise ValueError("Dimensions must be positive")
    return max(1, math.ceil((width * height) / ONE_MEGAPIXEL_PIXELS))


def budget_flux_2_pro(
    accepted_target: int,
    width: int,
    height: int,
    acceptance_rate: float = 1.0,
) -> BatchEstimate:
    attempts = required_attempts(accepted_target, acceptance_rate)
    billed_mp = flux_2_pro_output_megapixels(width, height)
    extra_mp = max(0, billed_mp - 1)
    per_image = FLUX_2_PRO_FIRST_MP_USD + (Decimal(extra_mp) * FLUX_2_PRO_EXTRA_MP_USD)
    total = (per_image * Decimal(attempts)).quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
    effective = (total / Decimal(accepted_target)).quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
    return BatchEstimate(
        model="FLUX.2-pro",
        mode=f"{width}x{height} ({billed_mp} MP)",
        accepted_target=accepted_target,
        total_attempts=attempts,
        per_attempt_usd=per_image,
        total_batch_usd=total,
        effective_accepted_usd=effective,
    )


if __name__ == "__main__":
    nb_1k = budget_nano_banana_2(10_000, "1K", acceptance_rate=0.8)
    nb_2k = budget_nano_banana_2(10_000, "2K", acceptance_rate=1.0)
    nb_4k = budget_nano_banana_2(10_000, "4K", acceptance_rate=1.0)
    assert nb_1k.total_attempts == 12_500 and nb_1k.total_batch_usd == Decimal("251.2500")
    assert nb_2k.total_batch_usd == Decimal("303.0000")
    assert nb_4k.total_batch_usd == Decimal("453.0000")

    gpt_low = budget_gpt_image_2(10_000, "low", input_tokens=200)
    gpt_med = budget_gpt_image_2(10_000, "medium", input_tokens=200)
    gpt_high = budget_gpt_image_2(10_000, "high", input_tokens=200)
    assert gpt_low.total_batch_usd == Decimal("21.0000")
    assert gpt_med.total_batch_usd == Decimal("162.0000")
    assert gpt_high.total_batch_usd == Decimal("636.0000")

    flux_1mp = budget_flux_2_pro(10_000, 1024, 1024)
    flux_2mp = budget_flux_2_pro(10_000, 1448, 1448)
    flux_4mp = budget_flux_2_pro(10_000, 2048, 2048)
    assert flux_1mp.per_attempt_usd == Decimal("0.0090") and flux_1mp.total_batch_usd == Decimal("90.0000")
    assert flux_2mp.per_attempt_usd == Decimal("0.0135") and flux_2mp.total_batch_usd == Decimal("135.0000")
    assert flux_4mp.per_attempt_usd == Decimal("0.0225") and flux_4mp.total_batch_usd == Decimal("225.0000")

    print(
        json.dumps(
            {
                "nano_banana_2_1k_80pct_usd": str(nb_1k.total_batch_usd),
                "gpt_image_2_medium_1024_usd": str(gpt_med.total_batch_usd),
                "flux_2_pro_1mp_usd": str(flux_1mp.total_batch_usd),
                "flux_2_pro_4mp_usd": str(flux_4mp.total_batch_usd),
            }
        )
    )