Исправление ошибок Nano Banana 2: полное руководство по 429, 502, лимитам (2026)

Ошибки Nano Banana 2, такие как 429 RESOURCE_EXHAUSTED и 502 Bad Gateway, затрагивают API Gemini 3.1 Flash Image (gemini-3.1-flash-image-preview). Ошибка 429 составляет около 70% всех сбоев и означает, что вы превысили лимит запросов — подождите 60 секунд для сброса RPM или проверьте дневную квоту, которая сбрасывается в полночь по тихоокеанскому времени. Ошибка 502 указывает на то, что серверы Google вернули некорректный ответ, и обычно устраняется за 5-15 минут. В этом руководстве рассмотрены все коды ошибок Nano Banana 2 с проверенными лимитами, реальными примерами ответов API и готовым к продакшену кодом на Python и TypeScript.

Чем ошибки Nano Banana 2 отличаются от ошибок Nano Banana Pro

Если вы занимались отладкой ошибок Nano Banana и следовали руководствам, написанным для Nano Banana Pro, возможно, вы применяете неподходящие решения к вашей проблеме. Nano Banana 2 (model ID: gemini-3.1-flash-image-preview) и Nano Banana Pro (model ID: gemini-3-pro-image-preview) — это принципиально разные модели с различными структурами ценообразования, лимитами запросов и поведением при ошибках. Понимание этих различий — первый шаг к правильному исправлению ошибок и экономии времени на отладке.

Самое критическое различие — это ценообразование. Nano Banana 2 стоит $0,25 за миллион входных токенов и $60 за миллион выходных токенов для генерации изображений, тогда как Nano Banana Pro стоит $2,00 за миллион входных токенов и $120 за миллион выходных токенов (ai.google.dev/pricing, проверено 2 марта 2026). Это означает, что NB2 на 50-87% дешевле Pro в пересчёте на токен, а одно изображение разрешением 1K стоит примерно $0,067 для NB2 по сравнению с $0,134 для Pro. Эта разница в ценах важна для обработки ошибок, потому что стратегии повторных попыток имеют разные последствия для бюджета в зависимости от модели. Для детального сравнения Nano Banana 2 и Pro у нас есть специальная статья, охватывающая все технические различия.

Второе критическое различие заключается в том, что Nano Banana 2 классифицируется как модель «preview», что означает более строгие лимиты запросов по сравнению с устоявшимися моделями. Официальная документация Google прямо указывает, что «экспериментальные и preview-модели имеют более низкие лимиты» (ai.google.dev/docs/rate-limits, 2 марта 2026). На практике это означает, что ваш аккаунт Tier 1 может обрабатывать 10 RPM для генерации изображений NB2 по сравнению с потенциально более высокими лимитами для моделей без статуса preview. У обеих моделей — NB2 и Pro — нет бесплатного уровня для генерации изображений: если вы видите RESOURCE_EXHAUSTED на бесплатном аккаунте, ошибка сообщает, что генерация изображений попросту недоступна без включённой тарификации.

Одна техническая деталь, которая застаёт врасплох многих разработчиков, — это требование thought_signature в многоходовых диалогах. При использовании Nano Banana 2 в контексте диалога, где модель генерирует и текст, и изображения в нескольких раундах, необходимо включать thought_signature из предыдущего ответа в следующий запрос. Несоблюдение этого требования приводит к ошибке 400 Bad Request, которая выглядит запутанно, если вы не знаете об этом механизме. Данное поведение одинаково для NB2 и Pro, но поскольку NB2 новее, меньше руководств освещают этот аспект должным образом.

Диагностика ошибки Nano Banana 2 за 30 секунд

Прежде чем погружаться в детальные решения, воспользуйтесь этой таблицей быстрой справки, чтобы сопоставить вашу конкретную ошибку с правильным исправлением. Каждая ошибка Nano Banana 2 относится к одной из двух категорий: повторяемые ошибки, при которых следует реализовать автоматическую логику повтора, и неповторяемые ошибки, при которых нужно исправить что-то в запросе перед повторной попыткой. Определение категории вашей ошибки экономит время, которое могло быть потрачено на неправильный подход.

Самое важное, что необходимо понять: неудавшиеся запросы, возвращающие 429, 502 или 503, не тарифицируются Google. Вы платите только за успешную генерацию изображений. Это означает, что реализация логики повторных попыток не несёт никакого дополнительного риска для бюджета, что является значительным облегчением для разработчиков, обеспокоенных выходом затрат из-под контроля в сценариях ошибок. Если ваше приложение сталкивается со шквалом ошибок 429 при повторных попытках, ваш счёт остаётся точно таким же, как если бы эти повторы никогда не происходили. Для более широкого обзора обработки ошибок во всех моделях Nano Banana смотрите наше полное руководство по устранению ошибок Nano Banana.

Исправление ошибки 429 RESOURCE_EXHAUSTED — самой распространённой ошибки Nano Banana 2

Ошибка 429 RESOURCE_EXHAUSTED — безусловно самая частая ошибка при использовании Nano Banana 2, составляющая примерно 70% всех сбоев API. Эта ошибка означает, что вы достигли одного из четырёх измерений лимита запросов, которые Google применяет к запросам генерации изображений. Понимание того, какой именно лимит вы превысили, критически важно, поскольку каждый имеет свою стратегию восстановления и время ожидания.

При получении ошибки 429 API возвращает JSON-ответ следующего вида:

json
{
  "error": {
    "code": 429,
    "message": "Resource has been exhausted (e.g. check quota).",
    "status": "RESOURCE_EXHAUSTED",
    "details": [
      {
        "@type": "type.googleapis.com/google.rpc.ErrorInfo",
        "reason": "RATE_LIMIT_EXCEEDED",
        "metadata": {
          "consumer": "projects/YOUR_PROJECT_ID",
          "quota_limit": "GenerateContentRequestsPerMinutePerProjectPerModel",
          "quota_limit_value": "10"
        }
      }
    ]
  }
}

Поле metadata в ответе об ошибке — ваш самый ценный инструмент отладки. Поле quota_limit точно указывает, какой лимит вы превысили. Четыре измерения лимитов запросов для генерации изображений Nano Banana 2: RPM (запросы в минуту), TPM (токены в минуту), RPD (запросы в день) и IPM (изображения в минуту). Каждое измерение работает независимо, поэтому превышение одного не влияет на другие. Ваш аккаунт Tier 1 может иметь 10 RPM, но 1000 RPD — как только дневная квота исчерпана, необходимо ждать до полуночи по тихоокеанскому времени для сброса счётчика RPD, независимо от оставшегося RPM.

Самый быстрый способ исправления ошибок 429, связанных с RPM, — это просто подождать 60 секунд. Счётчик RPM сбрасывается по скользящему одноминутному окну, поэтому после 60 секунд без запросов ваша полная квота RPM снова становится доступной. Для лимитов RPD, однако, ожидание значительно дольше — счётчик сбрасывается в полночь по тихоокеанскому времени (UTC-8 или UTC-7 в период летнего времени). Если вы достигли лимита RPD в 9 утра по тихоокеанскому времени, вас ждёт 15-часовое ожидание, если только вы не повысите свой уровень.

Распространённая ошибка — отправка запросов с максимальной скоростью с расчётом на то, что логика повторов обработает ошибки 429. Хотя технически это работает, поскольку неудавшиеся запросы не тарифицируются, это неэффективно и создаёт ненужную нагрузку на серверы Google. Лучший подход — реализовать проактивное ограничение скорости на вашей стороне. Если вы знаете, что ваш лимит Tier 1 составляет 10 RPM, разнесите запросы минимум на 6 секунд, чтобы уверенно оставаться под лимитом. Это устраняет большинство ошибок 429 ещё до их возникновения. Многие из тех же принципов применимы к NB2 с поправкой на лимиты, подробнее в нашем руководстве по устранению ошибки 429 Nano Banana Pro.

Реализация экспоненциального отката — стандартное решение для оставшихся ошибок 429. Начните с задержки в 1 секунду после первого сбоя, удваивайте её при каждой последующей попытке (2 с, 4 с, 8 с, 16 с) и добавляйте небольшой случайный джиттер для предотвращения проблемы «стадного эффекта», когда несколько клиентов повторяют запросы одновременно. Ограничьте максимальную задержку 60 секундами для лимитов RPM и рассмотрите отказ после 5-6 попыток, если лимит скорее связан с RPD, а не с RPM.

Исправление ошибок 502 Bad Gateway и 503 Service Unavailable

Ошибки 502 Bad Gateway и 503 Service Unavailable — это серверные ошибки, указывающие на проблемы в инфраструктуре Google, а не с вашим запросом. Эти ошибки принципиально отличаются от 429, поскольку с вашим кодом и использованием лимитов всё в порядке — серверы Google либо возвращают некорректные ответы (502), либо перегружены для обработки вашего запроса (503). Правильная реакция на обе ошибки — терпение и систематическая логика повторных попыток.

При получении ошибки 502 Bad Gateway ответ обычно выглядит так:

json
{
  "error": {
    "code": 502,
    "message": "Bad Gateway",
    "status": "UNAVAILABLE"
  }
}

Ошибка 502 означает, что обратный прокси или балансировщик нагрузки перед API Gemini получил некорректный ответ от upstream-сервера, обрабатывающего ваш запрос. Это может происходить во время развёртывания серверов, обновления инфраструктуры или кратковременных сетевых проблем в центрах обработки данных Google. Ключевой вывод: ошибки 502 почти всегда временные — они обычно устраняются в течение 5-15 минут без каких-либо действий с вашей стороны. Если вы наблюдаете постоянные ошибки 502 более 30 минут, проверьте Google Cloud Status Dashboard на предмет текущих инцидентов, затрагивающих API Gemini.

Ошибка 503 Service Unavailable следует другому паттерну. Если ошибки 502 обычно представляют собой кратковременные сбои, ошибки 503 часто указывают на устойчивую перегрузку сервера, что более характерно в часы пиковой нагрузки. На основе отчётов сообщества и наших собственных тестов, пиковые частоты ошибок Nano Banana 2 группируются между 10:00 и 14:00 UTC в будние дни, что соответствует пересечению утреннего времени в США и дневного времени в Европе. Если ваше приложение не зависит от времени, планирование запросов генерации изображений в непиковые часы (раннее утро UTC или выходные) может значительно снизить частоту ошибок 503.

Тело ответа 503 похоже на 502, но обычно содержит более специфическую информацию о загрузке сервера:

json
{
  "error": {
    "code": 503,
    "message": "The model is overloaded. Please try again later.",
    "status": "UNAVAILABLE"
  }
}

Для пользователей MCP (Model Context Protocol), обращающихся к Nano Banana 2 через инструменты вроде Cherry Studio, Claude Code или Dify, эти серверные ошибки могут проявляться в запутанной форме, поскольку уровень MCP добавляет собственную обёртку ошибок. Если вы видите ошибки типа «upstream connection error» или «model not responding» в вашем MCP-клиенте, основная причина — скорее всего ошибка 502 или 503 от API Gemini. Решение то же: подождать и повторить. Пользователям Cherry Studio в частности стоит проверить серверные логи (обычно в ~/.cherry-studio/logs/), чтобы увидеть фактический HTTP-код статуса от API, что помогает различить проблемы на уровне MCP и реальные сбои API.

Обе ошибки — 502 и 503 — следует обрабатывать стратегией повторов с более длительными начальными задержками, чем для ошибок 429. Начните с задержки в 5 секунд для первого повтора, увеличьте до 15 секунд, затем 30 секунд и ограничьте максимум 60 секундами. Поскольку эти ошибки указывают на серверную нагрузку, агрессивные повторы могут фактически усугубить ситуацию. Допускайте максимум 3-4 повтора перед корректным завершением с понятным сообщением об ошибке, предлагающим попробовать через несколько минут.

Исправление клиентских ошибок — 400 Bad Request, 403 Forbidden и IMAGE_SAFETY

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

400 Bad Request — наиболее разнообразная клиентская ошибка, поскольку охватывает несколько режимов сбоя. Самая распространённая причина конкретно для Nano Banana 2 — это отсутствие thought_signature в многоходовых диалогах. Когда NB2 возвращает ответ, содержащий токены размышлений (что происходит, даже если вы установили видимость размышлений на «off» — токены размышлений всегда тарифицируются независимо от ваших настроек), ответ включает поле thought_signature, которое необходимо передать обратно в следующем запросе в рамках того же диалога. Вот как выглядит ошибка при отсутствии подписи:

json
{
  "error": {
    "code": 400,
    "message": "Request contains an invalid argument: thought_signature is required for multi-turn conversations with this model.",
    "status": "INVALID_ARGUMENT"
  }
}

Исправление простое, но легко упускается из виду: извлеките thought_signature из ответа модели и включите его в generation_config следующего запроса. Если вы используете фреймворк или SDK, управляющий историей диалога, убедитесь, что он сохраняет это поле между ходами. Многие популярные фреймворки, включая LangChain и некоторые реализации MCP-серверов, пока не обрабатывают это автоматически, поэтому может потребоваться добавить пользовательскую логику для извлечения и внедрения подписи.

Другие причины ошибки 400 включают недопустимые соотношения сторон (NB2 поддерживает определённые соотношения, такие как 1:1, 3:4, 4:3, 9:16, 16:9 и другие — полный список в официальной документации), запрос неподдерживаемых размеров изображений или отправку слишком большого количества референсных изображений. Nano Banana 2 поддерживает до 14 референсных изображений (10 объектов или 6 объектов плюс 5 персонажей), и превышение этого лимита вызывает ошибку 400 с описательным сообщением.

403 Forbidden обычно означает одно из трёх: ваш API-ключ недействителен или отозван, в вашем проекте Google Cloud не включён API Gemini, или ваш географический регион ограничен в доступе к сервису. Исправление зависит от конкретной причины. Сначала проверьте корректность API-ключа, протестировав его с простым текстовым запросом (который не требует тарификации). Если текстовые запросы работают, а генерация изображений — нет, вероятно, нужно включить тарификацию в проекте: помните, у Nano Banana 2 нет бесплатного уровня для генерации изображений.

Блокировки IMAGE_SAFETY — особая категория. Это не HTTP-ошибки в традиционном смысле: API возвращает статус 200 OK, но тело ответа указывает, что сгенерированное изображение было заблокировано фильтрами безопасности Google. Ответ выглядит так:

json
{
  "candidates": [
    {
      "finishReason": "IMAGE_SAFETY",
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "HIGH",
          "blocked": true
        }
      ]
    }
  ]
}

Когда это происходит, модель попыталась сгенерировать изображение, но результат был отфильтрован перед отправкой. Заблокированные по безопасности генерации не тарифицируются. Для решения перефразируйте промпт, избегая контента, который активирует фильтры безопасности. Добавление явных стилистических указаний, таких как «professional photograph», «editorial style» или «clean illustration», помогает направить модель в сторону от контента, который может быть отфильтрован. Избегайте неоднозначных формулировок, которые могут быть истолкованы несколькими способами, поскольку система безопасности склонна к осторожности.

Лимиты запросов Nano Banana 2 — все уровни и ограничения

Понимание полной системы лимитов запросов необходимо для предотвращения ошибок до их возникновения. Google структурирует лимиты Nano Banana 2 по четырём измерениям и четырём уровням, и каждая комбинация имеет конкретное числовое ограничение, определяющее, сколько запросов ваш проект может выполнить. Все данные верифицированы напрямую с ai.google.dev/gemini-api/docs/rate-limits от 2 марта 2026. Подробный обзор лимитов всех моделей Gemini доступен в нашем полном разборе лимитов API Gemini по уровням.

Четыре измерения лимитов работают независимо. RPM (запросы в минуту) ограничивает количество вызовов API независимо от их размера. TPM (токены в минуту) ограничивает общий объём токенов во всех запросах. RPD (запросы в день) устанавливает дневной потолок, сбрасывающийся в полночь по тихоокеанскому времени. IPM (изображения в минуту) специально ограничивает выход генерации изображений. Вы можете достичь любого из этих лимитов, не затрагивая остальные — например, у вас может оставаться ёмкость RPM, но быть исчерпана квота IPM за минуту.

Лимиты применяются к проекту Google Cloud, а не к API-ключу. Это критически важное различие, которое многие разработчики упускают. Если вы создаёте несколько API-ключей в одном проекте, надеясь умножить лимиты, это не сработает. Все ключи в рамках одного проекта используют один пул лимитов. Чтобы реально увеличить эффективный лимит, потребуется создать отдельные проекты Google Cloud, но этот подход имеет свои сложности с управлением тарификацией и в целом не рекомендуется без конкретной архитектурной причины.

Система уровней Google прогрессирует от Free через Tier 1, Tier 2 и Tier 3. Бесплатный уровень не поддерживает генерацию изображений Nano Banana 2 вообще — вы немедленно получите ошибку 429, если попытаетесь генерировать изображения без включённой тарификации. Tier 1 активируется при включении тарификации и предоставляет базовые лимиты для генерации изображений. Tier 2 требует $250 и более совокупных расходов за последние 30 дней, а Tier 3 — $1000 и более. Каждое повышение уровня приносит значительно более высокие лимиты по всем четырём измерениям.

Для аккаунтов Tier 1 практическое следствие таково: вы можете генерировать примерно 10 изображений в минуту и до 1000 в день. Если ваше приложение обрабатывает запросы пользователей в реальном времени, это означает примерно один запрос на изображение каждые 6 секунд при устойчивой нагрузке или кратковременные всплески до 10 одновременных запросов с последующим обязательным периодом охлаждения. Для приложений, обрабатывающих изображения пакетно (генерация каталогов продуктов или контента для социальных сетей), лимит RPD в 1000 в день часто является ограничивающим фактором, а не RPM.

Batch API предлагает альтернативу для высоконагруженных сценариев. Nano Banana 2 поддерживает пакетную обработку с лимитами очереди в 1 миллион токенов (Tier 1), 250 миллионов (Tier 2) и 750 миллионов (Tier 3). Пакетные запросы обрабатываются асинхронно с более низким приоритетом, но не подчиняются тем же RPM-лимитам, что и синхронные запросы. Если ваш сценарий не требует генерации изображений в реальном времени, Batch API может значительно увеличить пропускную способность без необходимости повышения уровня. Сервисы вроде laozhang.ai предоставляют доступ к Nano Banana 2 со смягчёнными лимитами по цене примерно $0,05 за изображение, что может быть практичной альтернативой для разработчиков, которым нужна более высокая пропускная способность без сложностей управления несколькими проектами Google Cloud или ожидания повышения уровня.

Готовый к продакшену код обработки ошибок для Nano Banana 2

Реализация надёжной обработки ошибок требует большего, чем просто оборачивание вызовов API в блоки try-catch. Решение, готовое к продакшену, должно включать экспоненциальный откат с джиттером, паттерн размыкателя цепи (circuit breaker) для предотвращения бомбардировки неработающего сервиса и очередь запросов для проактивного соблюдения лимитов. Ниже представлены полные реализации на Python и TypeScript, которые можно адаптировать для вашей интеграции с Nano Banana 2.

Реализация на Python

python
import time
import random
import google.generativeai as genai
from collections import deque
from threading import Lock

class NanoBanana2Client:
    """Production error handler for Nano Banana 2 (gemini-3.1-flash-image-preview)"""

    MODEL_ID = "gemini-3.1-flash-image-preview"

    def __init__(self, api_key: str, max_rpm: int = 10):
        genai.configure(api_key=api_key)
        self.model = genai.GenerativeModel(self.MODEL_ID)
        self.max_rpm = max_rpm
        self.request_timestamps = deque()
        self.lock = Lock()
        self.circuit_open = False
        self.circuit_failures = 0
        self.circuit_threshold = 5
        self.circuit_reset_time = 0

    def _wait_for_rate_limit(self):
        """Proactive rate limiting - prevent 429 before it happens"""
        with self.lock:
            now = time.time()
            # Remove timestamps older than 60 seconds
            while self.request_timestamps and self.request_timestamps[0] < now - 60:
                self.request_timestamps.popleft()

            if len(self.request_timestamps) >= self.max_rpm:
                wait_time = 60 - (now - self.request_timestamps[0]) + 0.1
                if wait_time > 0:
                    time.sleep(wait_time)

            self.request_timestamps.append(time.time())

    def _check_circuit_breaker(self):
        """Circuit breaker - stop hammering a failing service"""
        if self.circuit_open:
            if time.time() > self.circuit_reset_time:
                self.circuit_open = False
                self.circuit_failures = 0
            else:
                raise Exception(
                    f"Circuit breaker open. Retry after "
                    f"{int(self.circuit_reset_time - time.time())}s"
                )

    def generate_image(self, prompt: str, max_retries: int = 5, **kwargs):
        """Generate image with full error handling"""
        self._check_circuit_breaker()
        self._wait_for_rate_limit()

        for attempt in range(max_retries):
            try:
                response = self.model.generate_content(
                    prompt,
                    generation_config=genai.types.GenerationConfig(
                        response_mime_type="image/png",
                        **kwargs
                    )
                )

                # Check for IMAGE_SAFETY block
                if hasattr(response, 'candidates') and response.candidates:
                    candidate = response.candidates[0]
                    if hasattr(candidate, 'finish_reason'):
                        if candidate.finish_reason.name == "IMAGE_SAFETY":
                            return {"error": "IMAGE_SAFETY", "retryable": False,
                                    "message": "Content blocked by safety filter"}

                # Success - reset circuit breaker
                self.circuit_failures = 0
                return {"success": True, "response": response}

            except Exception as e:
                error_code = getattr(e, 'code', None) or self._extract_code(str(e))

                if error_code == 429:
                    # Rate limit - exponential backoff with jitter
                    delay = min(60, (2 ** attempt) + random.uniform(0, 1))
                    time.sleep(delay)
                    continue

                elif error_code in (502, 503):
                    # Server error - longer backoff
                    self.circuit_failures += 1
                    if self.circuit_failures >= self.circuit_threshold:
                        self.circuit_open = True
                        self.circuit_reset_time = time.time() + 120
                    delay = min(60, 5 * (2 ** attempt) + random.uniform(0, 2))
                    time.sleep(delay)
                    continue

                elif error_code in (400, 403):
                    # Client error - do not retry
                    return {"error": error_code, "retryable": False,
                            "message": str(e)}
                else:
                    # Unknown error
                    return {"error": "UNKNOWN", "retryable": False,
                            "message": str(e)}

        return {"error": "MAX_RETRIES", "retryable": True,
                "message": f"Failed after {max_retries} attempts"}

    def _extract_code(self, error_str: str) -> int:
        for code in [429, 502, 503, 500, 400, 403]:
            if str(code) in error_str:
                return code
        return 0

Реализация на TypeScript / Node.js

typescript
import { GoogleGenerativeAI } from "@google/generative-ai";

interface GenerationResult {
  success: boolean;
  response?: any;
  error?: string;
  retryable?: boolean;
  message?: string;
}

class NanoBanana2Client {
  private static MODEL_ID = "gemini-3.1-flash-image-preview";
  private model: any;
  private requestTimestamps: number[] = [];
  private maxRpm: number;
  private circuitOpen = false;
  private circuitFailures = 0;
  private circuitThreshold = 5;
  private circuitResetTime = 0;

  constructor(apiKey: string, maxRpm = 10) {
    const genAI = new GoogleGenerativeAI(apiKey);
    this.model = genAI.getGenerativeModel({
      model: NanoBanana2Client.MODEL_ID
    });
    this.maxRpm = maxRpm;
  }

  private async waitForRateLimit(): Promise<void> {
    const now = Date.now();
    this.requestTimestamps = this.requestTimestamps
      .filter(ts => ts > now - 60000);

    if (this.requestTimestamps.length >= this.maxRpm) {
      const waitMs = 60000 - (now - this.requestTimestamps[0]) + 100;
      if (waitMs > 0) await this.sleep(waitMs);
    }
    this.requestTimestamps.push(Date.now());
  }

  async generateImage(
    prompt: string,
    maxRetries = 5
  ): Promise<GenerationResult> {
    if (this.circuitOpen) {
      if (Date.now() > this.circuitResetTime) {
        this.circuitOpen = false;
        this.circuitFailures = 0;
      } else {
        const waitSec = Math.ceil(
          (this.circuitResetTime - Date.now()) / 1000
        );
        return { success: false, error: "CIRCUIT_OPEN",
          retryable: true,
          message: `Circuit breaker open. Retry in ${waitSec}s` };
      }
    }

    await this.waitForRateLimit();

    for (let attempt = 0; attempt < maxRetries; attempt++) {
      try {
        const result = await this.model.generateContent({
          contents: [{ role: "user", parts: [{ text: prompt }] }],
          generationConfig: { responseMimeType: "image/png" },
        });

        const candidate = result.response?.candidates?.[0];
        if (candidate?.finishReason === "IMAGE_SAFETY") {
          return { success: false, error: "IMAGE_SAFETY",
            retryable: false,
            message: "Content blocked by safety filter" };
        }

        this.circuitFailures = 0;
        return { success: true, response: result.response };

      } catch (err: any) {
        const code = err?.status || err?.code ||
          this.extractCode(err.message);

        if (code === 429) {
          const delay = Math.min(60000,
            (2 ** attempt) * 1000 + Math.random() * 1000);
          await this.sleep(delay);
          continue;
        }

        if (code === 502 || code === 503) {
          this.circuitFailures++;
          if (this.circuitFailures >= this.circuitThreshold) {
            this.circuitOpen = true;
            this.circuitResetTime = Date.now() + 120000;
          }
          const delay = Math.min(60000,
            5000 * (2 ** attempt) + Math.random() * 2000);
          await this.sleep(delay);
          continue;
        }

        if (code === 400 || code === 403) {
          return { success: false, error: String(code),
            retryable: false, message: err.message };
        }

        return { success: false, error: "UNKNOWN",
          retryable: false, message: err.message };
      }
    }

    return { success: false, error: "MAX_RETRIES",
      retryable: true,
      message: `Failed after ${maxRetries} attempts` };
  }

  private sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  private extractCode(msg: string): number {
    for (const code of [429, 502, 503, 500, 400, 403]) {
      if (msg?.includes(String(code))) return code;
    }
    return 0;
  }
}

Обе реализации разделяют три ключевых архитектурных паттерна, которые делают их готовыми к продакшену. Во-первых, проактивное ограничение скорости отслеживает временные метки запросов и задерживает новые запросы до достижения лимитов Google, предотвращая большинство ошибок 429 ещё до их возникновения. Во-вторых, паттерн размыкателя цепи (circuit breaker) обнаруживает, когда сервер находится в деградированном состоянии (после 5 последовательных сбоев), и временно прекращает отправку запросов на 2 минуты, давая серверу время на восстановление, вместо того чтобы усугублять перегрузку. В-третьих, стратегия экспоненциального отката с джиттером использует прогрессивно увеличивающиеся задержки между повторами, добавляя случайность для предотвращения одновременных повторов от нескольких клиентов.

Что делать, если ошибки продолжаются — альтернативы и оптимизация затрат

Если вы реализовали все стратегии обработки ошибок, описанные выше, и по-прежнему регулярно упираетесь в лимиты, проблема, скорее всего, архитектурная, а не техническая. Вы переросли ёмкость текущего уровня, и перед вами три практических пути: повысить уровень Google Cloud, оптимизировать паттерны запросов или использовать прокси-сервис API с более высокими лимитами.

Повышение уровня — самое прямолинейное решение, но требует достижения порогов расходов Google. Переход с Tier 1 на Tier 2 требует $250 совокупных расходов на API за 30 дней, что утраивает RPM с 10 до 30 и увеличивает RPD с 1000 до 5000 в пять раз. Для многих продакшен-приложений лимитов Tier 2 достаточно. Tier 3 ($1000+ расходов за 30 дней) удваивает всё ещё раз — до 60 RPM и 10 000 RPD, что обеспечивает значительную нагрузку. Переход происходит автоматически при достижении порога расходов — нет процесса заявки или ручного утверждения.

Оптимизация паттернов запросов часто позволяет отсрочить или устранить необходимость повышения уровня. Рассмотрите внедрение очереди запросов, которая накапливает задачи генерации изображений и обрабатывает их с постоянной скоростью чуть ниже вашего RPM-лимита. Кэшируйте сгенерированные изображения, чтобы никогда не генерировать одно и то же изображение дважды для одного промпта. Используйте Batch API для не привязанных ко времени задач — он работает вне стандартных RPM-лимитов. И если вы генерируете изображения в нескольких разрешениях, начинайте с 512px ($0,045 за изображение) для предпросмотров и генерируйте более высокие разрешения только для подтверждённых вариантов.

Прокси-сервисы API предлагают третий путь, сочетающий более высокие лимиты с потенциальной экономией. Сервисы вроде laozhang.ai предоставляют доступ к Nano Banana 2 по цене примерно $0,05 за изображение без ограничений по лимитам, что конкурентоспособно с прямыми ценами Google на разрешении 1K ($0,067) и значительно дешевле для более высоких разрешений. Для самых дешёвых альтернатив API Nano Banana 2 у нас есть отдельное сравнение всех основных провайдеров. Компромисс в том, что прокси-сервисы добавляют сетевой переход и зависимость от стороннего провайдера, поэтому лучше всего подходят для некритичных нагрузок или в качестве резервного варианта при исчерпании основной квоты Google Cloud.

Вот практическое сравнение затрат на генерацию 1000 изображений в разрешении 1K в день:

Ценообразование Google одинаково для всех уровней — уровни влияют только на лимиты, а не на стоимость за изображение. Это означает, что ценность повышения уровня состоит исключительно в пропускной способности, а не в экономике единицы. Если стоимость — ваша главная забота и вы готовы работать с прокси-сервисом, можно сэкономить примерно 25% за изображение, получив фактически неограниченные лимиты. Документация доступна по адресу docs.laozhang.ai, а протестировать генерацию изображений можно на images.laozhang.ai.

Часто задаваемые вопросы

Как исправить ошибку 429 на Nano Banana 2?

Ошибка 429 RESOURCE_EXHAUSTED означает, что вы превысили один из четырёх лимитов: RPM (запросы в минуту), TPM (токены в минуту), RPD (запросы в день) или IPM (изображения в минуту). Быстрейшее исправление для лимитов RPM — подождать 60 секунд. Для лимитов RPD необходимо ждать до полуночи по тихоокеанскому времени. Реализуйте экспоненциальный откат в коде, начиная с задержки 1 секунда, удваивая при каждом повторе до максимума 60 секунд. Проактивно распределяйте запросы, чтобы оставаться ниже лимита — для аккаунтов Tier 1 это не более 10 запросов в минуту на генерацию изображений.

Каковы лимиты запросов для Nano Banana 2?

Лимиты Nano Banana 2 (gemini-3.1-flash-image-preview) зависят от уровня. Tier 1 (тарификация включена) допускает 10 RPM, 4M TPM, 1000 RPD и 10 IPM для генерации изображений. Tier 2 ($250+ расходов за 30 дней) допускает 30 RPM, 10M TPM, 5000 RPD и 30 IPM. Tier 3 ($1000+ расходов) допускает 60 RPM, 20M TPM, 10 000 RPD и 60 IPM. Бесплатный уровень не поддерживает генерацию изображений. Лимиты привязаны к проекту, а не к API-ключу, и были верифицированы с ai.google.dev 2 марта 2026.

Почему Nano Banana 2 постоянно выдаёт ошибки 502?

Ошибка 502 Bad Gateway указывает на проблему на серверах Google, а не с вашим кодом. Эти ошибки обычно устраняются в течение 5-15 минут. Они наиболее часты в часы пиковой нагрузки (10:00-14:00 UTC). Реализуйте логику повторов с начальной задержкой 5 секунд, увеличивая до 30-60 секунд. Если ошибки 502 сохраняются более 30 минут, проверьте Google Cloud Status Dashboard на предмет инцидентов. За неудавшиеся запросы 502 плата не взимается.

Бесплатен ли Nano Banana 2?

Текстовые запросы Nano Banana 2 доступны на бесплатном уровне, но генерация изображений требует включённой тарификации (Tier 1 или выше). Бесплатного уровня для генерации изображений NB2 не существует. Стоимость за изображение составляет от $0,045 (512px) до $0,151 (разрешение 4K). Входные токены стоят $0,25 за миллион, а выходные токены для изображений — $60 за миллион, как верифицировано на официальной странице цен Google 2 марта 2026.

Что такое ошибка thought_signature в Nano Banana 2?

Ошибка thought_signature (400 Bad Request) возникает в многоходовых диалогах, когда вы не включаете thought_signature из предыдущего ответа модели. Даже если вы установили видимость размышлений на «off», NB2 всё равно генерирует токены размышлений и включает подпись, которую необходимо передать обратно в последующих ходах. Извлеките поле thought_signature из ответа API и включите его в generation_config следующего запроса для устранения этой ошибки.

Чем отличается обработка ошибок Nano Banana 2 от Pro?

Nano Banana 2 и Pro используют одни и те же коды ошибок (429, 502, 503, 400, 403, IMAGE_SAFETY), но отличаются лимитами запросов и ценообразованием. NB2 на 50-87% дешевле за токен, но работает с более строгими лимитами как preview-модель. Входная стоимость NB2 составляет $0,25/1M токенов против $2,00/1M у Pro, а выходная — $60/1M против $120/1M у Pro. У обеих моделей нет бесплатного уровня для генерации изображений. С точки зрения устойчивости к ошибкам, Pro может иметь несколько более щедрые лимиты на том же уровне благодаря своему статусу без пометки preview.