Nano Banana Pro: Справочник по кодам ошибок — исправьте любую ошибку API за 60 секунд (2026)

Все ошибки Nano Banana Pro делятся на три категории: ошибки на стороне клиента, которые можно исправить немедленно (400, 403, 404), ошибки на стороне сервера, требующие терпения и логики повторных попыток (429, 500, 503, 504), и ошибки безопасности при генерации изображений, требующие изменения промпта (SAFETY, IMAGE_SAFETY). Этот справочник охватывает все 8 официальных кодов ошибок, верифицированных по документации Google AI (ai.google.dev, февраль 2026), с однострочными исправлениями, классификацией повторяемости и 30-секундным диагностическим алгоритмом, который соответствует реальному процессу отладки в production-среде.

Полная таблица кодов ошибок Nano Banana Pro

Краткий ответ: Nano Banana Pro имеет 8 официальных HTTP-кодов ошибок (400, 403, 404, 429, 500, 503, 504) плюс специфичные ошибки изображений (SAFETY, IMAGE_SAFETY). Самая распространённая — 429 RESOURCE_EXHAUSTED (~70% всех ошибок), которая решается ожиданием в 60 секунд.

Приведённая ниже основная таблица кодов ошибок предназначена для одной цели: помочь вам перейти от сообщения об ошибке к решению менее чем за 10 секунд. Каждый код ошибки включает его официальный статус Google API, указание на то, следует ли повторить запрос или исправить код, и самый быстрый путь к решению. В отличие от подробных руководств по устранению неполадок, которые описывают каждую ошибку на тысячах слов, эта таблица даёт вам всю необходимую информацию одним взглядом — добавьте эту страницу в закладки и возвращайтесь к ней каждый раз, когда что-то ломается.

Разделение на повторяемые и неповторяемые ошибки — это самый важный принцип, который передаёт эта таблица, поскольку он напрямую определяет ваше следующее действие. Когда вы видите повторяемую ошибку (429, 500, 503, 504), правильная реакция — подождать и отправить точно такой же запрос снова: ваш код в порядке, серверу просто нужно время. Когда вы видите неповторяемую ошибку (400, 403, 404, SAFETY, IMAGE_SAFETY), повторная отправка идентичного запроса каждый раз будет давать одинаковый результат, поэтому вы должны изменить что-то в запросе перед повторной попыткой. Эта классификация — то, чего не предоставляет ни один другой справочник, хотя именно она является наиболее практичной информацией для разработчика, смотрящего на ошибку в терминале.

Данные сообщества разработчиков с форумов и обсуждений Google AI Studio неизменно показывают, что примерно 70% всех ошибок Nano Banana Pro приходится на 429 RESOURCE_EXHAUSTED, а это означает, что подавляющее большинство ошибок, с которыми вы сталкиваетесь, являются временными и самоустраняющимися. Серверные ошибки (500, 502, 503 в сумме) составляют примерно 15%, ошибки аутентификации (403) — около 8%, а оставшиеся ошибки, включая IMAGE_SAFETY и таймауты, составляют последние 7%. Понимание этого распределения помогает вам расставлять приоритеты при отладке — если ваше приложение сбоит периодически, ограничение по частоте запросов почти наверняка является причиной. Для более глубокого разбора каждого кода ошибки и его граничных случаев смотрите полный центр устранения неполадок Nano Banana Pro.

Ошибки на стороне клиента — исправьте прямо сейчас (400, 403, 404)

Краткий ответ: Ошибки на стороне клиента означают, что проблема в вашем запросе, а не на серверах Google. Они неповторяемые — вы должны устранить основную причину, прежде чем запрос сможет выполниться успешно. Самые частые исправления — корректировка некорректного JSON, перегенерация API-ключа и проверка имени модели.

Ошибки на стороне клиента в диапазоне 4xx наиболее раздражают, потому что они сообщают о том, что в вашем коде или конфигурации что-то не так, но сообщения об ошибках Gemini API не всегда достаточно конкретны, чтобы точно определить проблему. Хорошая новость в том, что эти ошибки имеют детерминированные решения: как только вы определите и устраните первопричину, ошибка исчезает навсегда. В отличие от серверных ошибок, которые появляются и исчезают непредсказуемо, ошибка 400 или 403 будет сохраняться, пока вы не внесёте изменения в код, что на самом деле делает их более удобными для систематической отладки.

Ошибка 400 INVALID_ARGUMENT — самая распространённая ошибка на стороне клиента и обычно означает, что тело вашего запроса содержит некорректный JSON, недопустимое значение параметра или отсутствующее обязательное поле. Gemini API особенно строг к формату запросов на генерацию изображений — типичные ошибки включают использование устаревших имён параметров, отправку пустой строки промпта или указание недопустимого размера изображения. Чтобы быстро диагностировать эту ошибку, сравните тело вашего запроса с примерами из руководства по интеграции API и найдите структурные различия. Связанный вариант, 400 FAILED_PRECONDITION, появляется, когда вы пытаетесь использовать функцию бесплатного тарифа, которая недоступна в вашем регионе, или когда в вашем проекте не настроен биллинг.

Ошибка 403 PERMISSION_DENIED указывает на то, что ваш API-ключ либо не существует, был отозван, либо не имеет необходимых разрешений для доступа к модели Nano Banana Pro. Эта ошибка часто настигает разработчиков, которые создали ключ для одного проекта Google Cloud, но отправляют запросы к другому проекту, или ограничили доступ ключа к API, исключив Generative Language API. Самый быстрый способ исправления — перейти в консоль Google AI Studio, сгенерировать новый API-ключ и заменить старый в коде. Если вы используете Vertex AI вместо прямого Gemini API, убедитесь, что сервисный аккаунт имеет разрешение aiplatform.endpoints.predict и что Vertex AI API включён в вашем проекте.

Ошибка 404 NOT_FOUND возникает, когда путь к ресурсу в вашем запросе не соответствует ни одной существующей модели или эндпоинту. Для Nano Banana Pro конкретно самая частая причина — использование неправильного идентификатора модели. Официальное имя модели, которое должно присутствовать в ваших API-вызовах, привязано к варианту «Gemini 3 Pro Image Preview», и разработчики иногда путают его с другими моделями Gemini или используют устаревшие названия из более ранних preview-версий. Дважды проверьте, что URL вашего эндпоинта соответствует шаблону https://generativelanguage.googleapis.com/v1beta/models/{model-name}:generateContent и что имя модели точно совпадает с тем, что отображается в селекторе моделей Google AI Studio.

Серверные ошибки — когда ждать, а когда переключаться (429, 500, 503, 504)

Краткий ответ: Серверные ошибки повторяемые — ваш код правильный, но сервер не может обработать ваш запрос прямо сейчас. Ошибка 429 требует ожидания 60 секунд, 500 — экспоненциального отката, 503 означает перегрузку сервиса (ждите 30-120 минут), а 504 — таймаут вашего запроса.

Серверные ошибки требуют принципиально иного подхода к устранению неполадок, чем ошибки на стороне клиента, поскольку проблема находится в инфраструктуре Google, а не в вашем коде. Правильная реакция на любую ошибку 5xx — реализовать логику повторных попыток с подходящими интервалами отката, а правильная реакция на ошибку 429 — соблюсти ограничение по частоте, приостановив отправку запросов. Попытка «исправить» серверную ошибку путём изменения параметров запроса — пустая трата времени, потому что идентичный запрос был бы успешным, если бы сервер находился в нормальном состоянии.

Ошибка 429 RESOURCE_EXHAUSTED заслуживает отдельного подробного разбора, потому что она составляет примерно 70% всех сбоев Nano Banana Pro по данным сообщества разработчиков. Gemini API применяет ограничения по частоте запросов одновременно по четырём измерениям: RPM (запросов в минуту), TPM (токенов в минуту для ввода), RPD (запросов в день) и IPM (изображений в минуту, специфично для Nano Banana Pro). Превышение любого одного измерения вызывает ошибку 429. Критически важная деталь, которую многие разработчики упускают: ограничения по частоте рассчитываются на проект, а не на API-ключ — создание нескольких API-ключей в рамках одного проекта Google Cloud не увеличивает вашу квоту (документация Google AI, верифицировано 19 февраля 2026). Лимиты RPD сбрасываются в полночь по тихоокеанскому времени, что означает, что разработчикам в других часовых поясах нужно планировать окна пакетной обработки соответственно. Для подробных стратегий работы с ограничениями по частоте и расчётов смотрите наш детальный анализ ограничений по частоте.

Ошибка 500 INTERNAL сигнализирует о неожиданном сбое на серверах Google и является самой сложной для диагностики ошибкой, поскольку предоставляет минимальную диагностическую информацию. Данные сообщества показывают, что эти ошибки обычно разрешаются в течение 30 секунд — 5 минут, что делает экспоненциальный откат идеальной стратегией. Начните с задержки в 30 секунд, удваивайте задержку при каждой повторной попытке, добавляйте случайный джиттер 0-5 секунд для предотвращения проблемы «стада» и ограничьте максимум 5 попытками перед оповещением. Если вы постоянно видите ошибки 500 в течение нескольких последовательных минут, проблема, скорее всего, связана с более широким сбоем инфраструктуры Google, а не с чем-то специфичным для вашего запроса, и проверка Google Cloud Status Dashboard подтвердит, есть ли активный инцидент.

Ошибка 503 UNAVAILABLE — вторая по влиянию серверная ошибка, возникающая, когда Nano Banana Pro испытывает высокий спрос, превышающий пропускную способность серверов Google. Эта ошибка была особенно частой во время первоначального запуска модели в preview-режиме и всё ещё появляется в периоды пиковой нагрузки. Время восстановления обычно составляет от 30 до 120 минут по данным разработчиков, хотя серьёзные сбои могут длиться дольше. Когда вы сталкиваетесь с ошибкой 503, наиболее практичная немедленная реакция — переключиться на другую модель временно, если ваше приложение поддерживает резервную логику, или поставить запрос в очередь для повторной попытки с помощью системы фоновых задач. Ошибка 503 часто специфична для региона, поэтому запросы, маршрутизируемые через другие географические эндпоинты, могут быть успешными даже при перегрузке вашего основного региона.

Ошибка 504 DEADLINE_EXCEEDED означает, что обработка вашего запроса заняла больше времени, чем допускает порог таймаута сервера. Для запросов на генерацию изображений это обычно происходит при очень сложных промптах, описывающих детализированные сцены с множеством элементов, или когда система находится под умеренной нагрузкой и время обработки увеличивается. Исправление простое: увеличьте настройку таймаута на стороне клиента минимум до 120 секунд для запросов на генерацию изображений и рассмотрите упрощение промпта, если таймаут сохраняется. В отличие от ошибок 503, которые указывают на проблемы уровня сервиса, ошибки 504 обычно специфичны для отдельных запросов.

Ошибки генерации изображений (SAFETY, IMAGE_SAFETY, пустой вывод)

Краткий ответ: Ошибки, специфичные для изображений, возникают на трёх этапах: промпт отклонён до генерации (SAFETY/blockReason), сгенерированное изображение заблокировано после создания (IMAGE_SAFETY) и успешная генерация с пустым результатом (blank output). Каждый случай требует своего подхода к исправлению.

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

Уровень 1: Безопасность промпта (finishReason: SAFETY) срабатывает до начала генерации изображения и оценивает ваш текстовый промпт на соответствие политикам контента Google. Когда этот уровень срабатывает, вы получаете ответ с finishReason: SAFETY, а поле promptFeedback.blockReason указывает причину отклонения промпта. Блокировка SAFETY обычно активируется для промптов, содержащих откровенное насилие, язык ненависти или сексуально откровенный контент, но может также срабатывать для пограничных случаев, которые кажутся безобидными — промпты, упоминающие медицинские процедуры, определённые исторические события или конкретных публичных персон, по сообщениям, иногда вызывают ложные срабатывания. Исправление для блокировок Уровня 1 — перефразировать промпт, используя более нейтральный язык, сохраняя при этом ваш творческий замысел. Вместо описания конкретных насильственных действий опишите эмоциональные последствия; вместо именования реальных людей опишите характеристики персонажа.

Уровень 2: Безопасность изображения (finishReason: IMAGE_SAFETY) оценивает само сгенерированное изображение после создания, что означает, что серверы Google уже затратили вычислительные ресурсы на генерацию изображения, которое отбрасывается прежде, чем вы его увидите. Этот уровень отлавливает изображения, которые прошли фильтр промпта, но создали визуальный контент, нарушающий политики — например, промпт с просьбой создать «сцену исторической битвы» может пройти Уровень 1, но сгенерировать изображение с графическим насилием, которое вызовет срабатывание Уровня 2. При возникновении ошибок IMAGE_SAFETY попробуйте описать сцену с другого ракурса, добавить модификаторы стиля вроде «стилизованный», «минималистичный» или «в стиле акварели» для поощрения менее реалистичных результатов, или снизить уровень детализации в описании.

Уровень 3: Специальные блокировки (BlockedReason.OTHER) указывает на нарушение Условий использования, выходящее за рамки стандартных политик контента, и является наиболее ограничивающим из трёх уровней. Эту блокировку невозможно обойти только путём модификации промпта, поскольку она обычно указывает на то, что ваш контент был отмечен за повторные нарушения политик или относится к категории, которую Google явно запретила вне зависимости от формулировки.

Пустой вывод (без кода ошибки) — особенно запутанный режим сбоя, потому что API возвращает статус 200 OK с пустым массивом изображений или ответом, содержащим метаданные, но без фактических данных изображения. Это технически не является ошибкой с точки зрения API, поэтому код ошибки не генерируется. Пустой вывод чаще всего возникает, когда процесс генерации сталкивается с внутренней неоднозначностью, которая не позволяет создать полное изображение — слишком сложные промпты с противоречивыми элементами, крайне абстрактные концепции или запросы на изображения с большим количеством текста являются наиболее частыми триггерами. Исправление состоит в постепенном упрощении промпта: убирайте по одному элементу за раз, пока генерация не увенчается успехом, затем постепенно добавляйте элементы обратно, чтобы определить, какая комбинация вызывает пустой вывод.

Быстрый диагностический алгоритм — найдите решение за 30 секунд

Краткий ответ: При получении ошибки сначала проверьте HTTP-код статуса. 4xx означает — исправьте код, 429 — подождите сброса лимитов, 5xx — проблема на сервере, а не-HTTP ошибки (SAFETY/IMAGE_SAFETY) — измените промпт.

Приведённый ниже диагностический алгоритм соответствует естественному процессу устранения неполадок, которому следуют опытные разработчики при столкновении с ошибкой API в production-среде. Вместо последовательного чтения документации по ошибкам вы начинаете с самой широкой классификации (диапазон HTTP-кода статуса) и сужаете до конкретного исправления за два-три шага принятия решений. Этот подход отражает то, как отладка работает на практике — сначала вы определяете, проблема в вашем коде или на сервере, затем идентифицируете конкретную категорию ошибки и, наконец, применяете целевое исправление.

Шаг 1: Прочитайте HTTP-код статуса. Каждая ошибка Nano Banana Pro возвращает стандартный HTTP-код статуса, который немедленно сообщает вам семейство ошибки. Если вы видите код в диапазоне 400, проблема в вашем запросе и вам нужно изменить что-то перед повторной попыткой. Если вы видите конкретно 429, вы достигли лимита частоты запросов и должны подождать. Если вы видите код в диапазоне 500, проблема на стороне Google и ваш запрос корректен — нужно просто повторить позже. Если вы не видите HTTP-ошибки, но получаете пустой ответ или флаг SAFETY/IMAGE_SAFETY в теле ответа, вы имеете дело с ошибкой, специфичной для изображений.

Шаг 2: Определите конкретную ошибку. Внутри каждого семейства сузьте поиск до точной ошибки, используя поле status в ответе API. Для ошибок 4xx проверьте, является ли это INVALID_ARGUMENT (исправьте тело запроса), PERMISSION_DENIED (исправьте API-ключ) или NOT_FOUND (исправьте эндпоинт). Для 429 определите, какой лимит вы превысили: RPM (подождите 60 секунд), RPD (подождите до полуночи PT) или TPM (уменьшите размер запроса). Для ошибок 5xx проверьте: INTERNAL (повторите с откатом), UNAVAILABLE (подождите 30+ минут) или DEADLINE_EXCEEDED (увеличьте таймаут).

Шаг 3: Примените целевое исправление и проверьте. Выполните однострочное исправление из основной таблицы кодов ошибок, подождите соответствующий интервал и отправьте запрос снова. Если ошибка сохраняется после применения исправления, обратитесь к разделу подробного устранения неполадок для данного кода ошибки. Для периодических ошибок, которые появляются и исчезают, реализуйте шаблон обработчика ошибок для production из следующего раздела для автоматической обработки повторных попыток.

Ограничения по частоте запросов и сравнение тарифов

Краткий ответ: Ограничения по частоте Nano Banana Pro привязаны к проекту (а не к API-ключу) и действуют по 4 измерениям: RPM, TPM, RPD и IPM. Бесплатный тариф крайне ограничен. Переход на Tier 1 требует привязки платёжного аккаунта; для Tier 2 необходимо потратить $250+ и подождать 30 дней.

Понимание системы тарифов критически важно для принятия решения о том, стоит ли обновлять план Google AI Studio или изучить альтернативных API-провайдеров. Структура ограничений, верифицированная по официальной документации Google AI (ai.google.dev/rate-limits, обновлено 19 февраля 2026), показывает, что разрыв между бесплатным и платным тарифами огромен — пользователи Tier 1 получают примерно в 30 раз больше запросов в минуту, чем бесплатные пользователи. Требования к тарифам кумулятивные и привязаны ко времени: достижение Tier 2 требует как суммарных расходов более $250, так и активного платёжного аккаунта в течение 30 дней, что означает невозможность простого крупного единоразового платежа для немедленного доступа к более высоким лимитам.

Измерения ограничений работают одновременно, и превышение любого из них вызывает ошибку 429, даже если по остальным вы находитесь в пределах нормы. RPM (запросов в минуту) — наиболее часто превышаемый лимит для приложений пакетной обработки, отправляющих запросы с высокой частотой. RPD (запросов в день) срабатывает для приложений, которые распределяют запросы во времени, но генерируют большие объёмы. TPM (токенов в минуту) в первую очередь затрагивает приложения, отправляющие очень длинные промпты. IPM (изображений в минуту) уникален для Nano Banana Pro и конкретно ограничивает количество вызовов генерации изображений вне зависимости от других измерений.

Для разработчиков, которые постоянно упираются в ограничения по частоте и нуждаются в более высокой доступности, существуют два практических пути. Первый — обновление тарифа биллинга Google Cloud путём привязки платёжного метода и постепенного увеличения расходов для разблокировки лимитов Tier 2 и Tier 3. Второй — использование стороннего агрегатора API, такого как laozhang.ai, который предоставляет доступ к той же модели Nano Banana Pro через единый эндпоинт с экономичными вариантами доступа к API и более предсказуемой доступностью в периоды пикового спроса. Этот подход особенно ценен в периоды высокого спроса, когда прямой API Google часто возвращает ошибки 503 UNAVAILABLE, так как платформы-агрегаторы часто поддерживают несколько путей маршрутизации, которые могут обходить перегруженные регионы.

Шаблон обработчика ошибок для production

Краткий ответ: Обработчик ошибок для production должен классифицировать ошибки как повторяемые и неповторяемые, реализовать экспоненциальный откат с джиттером для повторяемых ошибок и логировать каждый сбой для мониторинга. Ниже приведены готовые реализации для Python и Node.js.

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

hljs pythonКопировать
import time
import random
import requests

class NanoBananaErrorHandler:
    RETRYABLE_CODES = {429, 500, 502, 503, 504}
    NON_RETRYABLE_CODES = {400, 403, 404}

    def __init__(self, api_key, max_retries=5, base_delay=30):
        self.api_key = api_key
        self.max_retries = max_retries
        self.base_delay = base_delay

    def generate_image(self, prompt, **kwargs):
        for attempt in range(self.max_retries):
            try:
                response = self._make_request(prompt, **kwargs)

                if response.status_code == 200:
                    data = response.json()
                    # Check for blank output
                    if not self._has_image(data):
                        return {"error": "blank_output",
                                "fix": "Simplify prompt"}
                    # Check for safety blocks in response
                    safety = self._check_safety(data)
                    if safety:
                        return {"error": safety["type"],
                                "fix": safety["action"]}
                    return {"success": True, "data": data}

                if response.status_code in self.NON_RETRYABLE_CODES:
                    return {"error": response.status_code,
                            "retryable": False,
                            "fix": self._get_fix(response.status_code)}

                if response.status_code in self.RETRYABLE_CODES:
                    delay = self._calculate_delay(attempt,
                                                  response.status_code)
                    time.sleep(delay)
                    continue

            except requests.Timeout:
                if attempt < self.max_retries - 1:
                    time.sleep(self.base_delay * (2 ** attempt))
                    continue

        return {"error": "max_retries_exceeded",
                "fix": "Check service status or switch provider"}

    def _calculate_delay(self, attempt, status_code):
        if status_code == 429:
            base = 60  # RPM resets every 60 seconds
        elif status_code == 503:
            base = 300  # 5 min minimum for overloaded
        else:
            base = self.base_delay * (2 ** attempt)
        jitter = random.uniform(0, base * 0.1)
        return base + jitter

    def _get_fix(self, code):
        fixes = {
            400: "Check request body and parameters",
            403: "Regenerate API key, verify permissions",
            404: "Verify model name and endpoint URL",
        }
        return fixes.get(code, "See error documentation")

hljs javascriptКопировать
// Node.js implementation
class NanoBananaErrorHandler {
  static RETRYABLE = new Set([429, 500, 502, 503, 504]);

  constructor(apiKey, { maxRetries = 5, baseDelay = 30000 } = {}) {
    this.apiKey = apiKey;
    this.maxRetries = maxRetries;
    this.baseDelay = baseDelay;
  }

  async generateImage(prompt, options = {}) {
    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
      try {
        const response = await this.makeRequest(prompt, options);

        if (response.ok) {
          const data = await response.json();
          if (!this.hasImage(data))
            return { error: "blank_output",
                     fix: "Simplify prompt" };
          const safety = this.checkSafety(data);
          if (safety) return safety;
          return { success: true, data };
        }

        if (!NanoBananaErrorHandler.RETRYABLE.has(response.status))
          return { error: response.status, retryable: false,
                   fix: this.getFix(response.status) };

        const delay = this.calcDelay(attempt, response.status);
        await new Promise(r => setTimeout(r, delay));
      } catch (err) {
        if (attempt === this.maxRetries - 1) throw err;
        await new Promise(r =>
          setTimeout(r, this.baseDelay * 2 ** attempt));
      }
    }
    return { error: "max_retries",
             fix: "Check status or switch provider" };
  }

  calcDelay(attempt, status) {
    const base = status === 429 ? 60000
               : status === 503 ? 300000
               : this.baseDelay * 2 ** attempt;
    return base + Math.random() * base * 0.1;
  }
}

Реализация на Python использует классовый подход, инкапсулирующий логику повторных попыток, классификацию ошибок и рекомендации по исправлению в единый переиспользуемый компонент. Метод _calculate_delay регулирует время ожидания на основе конкретного типа ошибки — ошибки 429 получают фиксированную задержку в 60 секунд, потому что лимиты RPM сбрасываются именно с таким циклом, тогда как ошибки 503 получают более длительную базовую задержку в 5 минут, поскольку перегрузка сервиса обычно требует больше времени на восстановление. Реализация на Node.js следует той же логике с использованием синтаксиса async/await. Для приложений, которым необходима более высокая надёжность, рассмотрите реализацию резервного переключения на вторичного API-провайдера, такого как laozhang.ai, когда основной эндпоинт стабильно возвращает ошибки 503 — этот паттерн особенно ценен в production-системах, где время простоя напрямую влияет на доход.

FAQ — Устранение ошибок Nano Banana Pro

Краткий ответ: Ниже приведены прямые ответы на наиболее часто задаваемые вопросы об ошибках Nano Banana Pro, полученные из форумов разработчиков и документации Google AI.

Что означает ошибка 429 для Nano Banana Pro?

Ошибка 429 RESOURCE_EXHAUSTED означает, что вы превысили одно из четырёх измерений ограничений по частоте: RPM (запросов в минуту), TPM (токенов в минуту), RPD (запросов в день) или IPM (изображений в минуту). Это самая распространённая ошибка Nano Banana Pro, составляющая примерно 70% всех зарегистрированных сбоев по данным сообщества разработчиков. Исправление зависит от того, какое измерение вы превысили — лимиты RPM сбрасываются каждые 60 секунд, поэтому короткая пауза обычно решает проблему. Лимиты RPD сбрасываются в полночь по тихоокеанскому времени. Ограничения по частоте рассчитываются на проект Google Cloud, а не на API-ключ, поэтому создание дополнительных ключей в рамках одного проекта не увеличит вашу квоту (верифицировано по документации Google AI, февраль 2026).

Как исправить ошибку перегрузки Nano Banana Pro?

Ошибка перегрузки соответствует HTTP 503 UNAVAILABLE и означает, что серверы Google испытывают высокий спрос. Это временная серверная проблема, требующая терпения, а не изменений в коде. По данным сообщества, типичное время восстановления составляет от 30 минут до 2 часов в периоды пикового спроса. Ваши варианты действий во время ожидания включают переключение на другой вариант модели Gemini, если ваше приложение это поддерживает, постановку неудачных запросов в очередь для автоматического повтора с помощью шаблона обработчика ошибок для production, представленного выше, или маршрутизацию через альтернативного API-провайдера, который поддерживает несколько путей доступа для снижения влияния региональных перегрузок.

Почему Nano Banana Pro постоянно блокирует мои изображения?

Блокировка изображений происходит через два отдельных уровня безопасности. Если ваш промпт заблокирован до генерации (finishReason: SAFETY), текстовое содержание само по себе вызвало нарушение политик — перефразируйте, используя более нейтральный язык, сохраняя творческий замысел. Если сгенерированное изображение заблокировано после создания (finishReason: IMAGE_SAFETY), визуальный результат нарушил политики, даже если ваш промпт был приемлемым — попробуйте добавить модификаторы стиля, такие как «акварель», «минимализм» или «абстракция», чтобы поощрить менее реалистичные результаты. Постоянные блокировки с BlockedReason.OTHER указывают на ограничение на уровне Условий использования, которое невозможно обойти через инженерию промптов. Подробные стратегии по работе с каждым уровнем безопасности смотрите в нашем руководстве по устранению неполадок с фильтрами безопасности.

Ограничения по частоте Nano Banana Pro привязаны к API-ключу или к проекту?

Ограничения по частоте рассчитываются на проект Google Cloud, а не на отдельный API-ключ. Это критически важная деталь, которую многие разработчики упускают — создание нескольких API-ключей в рамках одного проекта не даёт вам дополнительной квоты. Чтобы действительно увеличить ограничения по частоте, вам нужно либо обновить тариф биллинга (что требует как кумулятивных порогов расходов, так и 30-дневного периода ожидания), либо распределить запросы между несколькими отдельными проектами Google Cloud, каждый со своим платёжным аккаунтом.

В чём разница между ошибками SAFETY и IMAGE_SAFETY?

Ошибка SAFETY (finishReason: SAFETY) срабатывает при оценке промпта до начала генерации изображения, то есть ваш текстовый промпт был отклонён фильтром контента. Ошибка IMAGE_SAFETY (finishReason: IMAGE_SAFETY) срабатывает после генерации изображения, то есть ваш промпт прошёл текстовый фильтр, но результирующее изображение было отмечено фильтром визуального контента. Это различие важно, потому что ошибки SAFETY детерминированы (один и тот же промпт всегда будет заблокирован), тогда как ошибки IMAGE_SAFETY могут быть недетерминированными (один и тот же промпт может генерировать разные изображения, некоторые из которых проходят, а некоторые нет). При устранении неполадок IMAGE_SAFETY повторите тот же промпт 2-3 раза, прежде чем заключить, что сам промпт нуждается в модификации.