Nano Banana 2 오류 완전 해결: 429, 502, 속도 제한 가이드 (2026)

Nano Banana 2의 429 RESOURCE_EXHAUSTED, 502 Bad Gateway 같은 오류는 Gemini 3.1 Flash Image API(gemini-3.1-flash-image-preview)에서 발생합니다. 429 오류는 전체 장애의 약 70%를 차지하며 속도 제한을 초과했다는 의미입니다. RPM 초기화까지 60초를 기다리거나 일일 할당량(태평양 시간 자정에 초기화)을 확인하세요. 502 오류는 Google 서버가 잘못된 응답을 반환했다는 의미이며 보통 5~15분 내에 해결됩니다. 이 가이드는 모든 Nano Banana 2 오류 코드, 검증된 속도 제한, 실제 오류 응답 예시, Python과 TypeScript로 작성된 프로덕션용 수정 코드를 제공합니다.

Nano Banana 2 오류가 Nano Banana Pro와 다른 이유

Nano Banana 오류를 디버깅하면서 Nano Banana Pro용 가이드를 따라왔다면, 잘못된 해결 방법을 적용하고 있을 수 있습니다. Nano Banana 2(모델 ID: gemini-3.1-flash-image-preview)와 Nano Banana Pro(모델 ID: gemini-3-pro-image-preview)는 가격 구조, 속도 제한, 오류 동작이 근본적으로 다른 별개의 모델입니다. 이러한 차이를 이해하는 것이 오류를 올바르게 수정하고 불필요한 디버깅 시간을 피하는 첫 번째 단계입니다.

가장 중요한 차이는 가격입니다. Nano Banana 2는 이미지 생성 시 입력 토큰 100만 개당 $0.25, 출력 토큰 100만 개당 $60을 부과하는 반면, Nano Banana Pro는 입력 토큰 100만 개당 $2.00, 출력 토큰 100만 개당 $120을 부과합니다(ai.google.dev/pricing, 2026년 3월 2일 검증). 이는 NB2가 토큰당 기준으로 Pro보다 50~87% 저렴하다는 의미이며, 1K 해상도 이미지 한 장의 비용이 NB2는 약 $0.067, Pro는 $0.134입니다. 이 가격 차이는 재시도 전략의 비용 영향이 사용하는 모델에 따라 달라지기 때문에 오류 처리에서 중요합니다. Nano Banana 2와 Pro의 상세 비교는 별도 기사에서 모든 기술적 차이를 다루고 있습니다.

두 번째 중요한 차이는 Nano Banana 2가 "미리보기(preview)" 모델로 분류된다는 점입니다. 즉, 확정된 모델보다 더 엄격한 속도 제한이 적용됩니다. Google의 공식 문서에는 "실험적 및 미리보기 모델은 더 낮은 속도 제한을 가진다"고 명시되어 있습니다(ai.google.dev/docs/rate-limits, 2026년 3월 2일). 실제로 이는 Tier 1 계정에서 NB2 이미지 생성에 대해 10 RPM 정도의 제한이 적용될 수 있다는 의미입니다. NB2와 Pro 모두 이미지 생성에 대한 무료 등급이 없습니다. 무료 등급 계정에서 RESOURCE_EXHAUSTED가 표시되면, 결제를 활성화하지 않으면 이미지 생성을 사용할 수 없다는 의미입니다.

많은 개발자를 당황하게 하는 기술적 세부 사항 중 하나는 다중 턴 대화에서의 thought_signature 요구 사항입니다. Nano Banana 2를 여러 턴에 걸쳐 텍스트와 이미지를 모두 생성하는 대화 맥락에서 사용할 때, 이전 응답의 thought_signature를 다음 요청에 포함해야 합니다. 이를 포함하지 않으면 이 요구 사항을 모르는 경우 혼란스러운 400 Bad Request 오류가 발생합니다. 이 동작은 NB2와 Pro 모두 동일하지만, NB2가 더 새로운 모델이기 때문에 이를 제대로 다루는 튜토리얼이 더 적습니다.

30초 만에 Nano Banana 2 오류 진단하기

상세한 해결 방법에 들어가기 전에, 이 빠른 참조 표를 사용하여 정확한 오류와 올바른 수정 방법을 매칭하세요. 모든 Nano Banana 2 오류는 두 가지 범주 중 하나에 속합니다: 자동 재시도 로직을 구현해야 하는 재시도 가능 오류와, 다시 시도하기 전에 요청에서 문제를 수정해야 하는 재시도 불가 오류입니다. 오류가 어느 범주에 속하는지 파악하면 잘못된 접근 방식에 시간을 낭비하지 않을 수 있습니다.

가장 중요한 점은 429, 502, 503을 반환하는 실패한 요청에 대해 Google이 요금을 부과하지 않는다는 것입니다. 성공한 이미지 생성에 대해서만 비용이 발생합니다. 이는 재시도 로직을 구현해도 추가 비용 위험이 전혀 없다는 의미이며, 오류 상황에서 예산 초과를 걱정하는 개발자에게 큰 안도감을 줍니다. 재시도 중 429 오류가 많이 발생하더라도 요금은 재시도가 전혀 없었던 것과 동일합니다. 모든 Nano Banana 모델의 오류 처리에 대한 전반적인 개요는 Nano Banana 오류 해결 완전 가이드를 참고하세요.

429 RESOURCE_EXHAUSTED 오류 해결 — 가장 흔한 Nano Banana 2 오류

429 RESOURCE_EXHAUSTED 오류는 Nano Banana 2를 사용할 때 가장 자주 접하는 오류로, 전체 API 장애의 약 70%를 차지합니다. 이 오류는 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이지만 1,000 RPD일 수 있으며, 일일 할당량을 모두 사용하면 남은 RPM에 관계없이 태평양 시간 자정까지 기다려야 합니다.

RPM 관련 429 오류의 가장 빠른 해결 방법은 단순히 60초를 기다리는 것입니다. RPM 카운터는 롤링 1분 윈도우에서 초기화되므로, 60초간 요청을 하지 않으면 전체 RPM 할당량을 다시 사용할 수 있습니다. 그러나 RPD 제한의 경우 대기 시간이 훨씬 길어집니다. 카운터가 태평양 시간 자정(UTC-8 또는 써머타임 중 UTC-7)에 초기화됩니다. 태평양 시간 오전 9시에 RPD 제한에 도달하면 등급을 업그레이드하지 않는 한 15시간을 기다려야 합니다.

흔한 실수는 가능한 한 빠르게 요청을 보내고 재시도 로직에 의존하여 429 오류를 처리하는 것입니다. 실패한 요청에 요금이 부과되지 않으므로 기술적으로는 작동하지만, 비효율적이며 Google 서버에 불필요한 부하를 만듭니다. 더 나은 접근 방식은 사전에 자체적으로 속도 제한을 구현하는 것입니다. Tier 1 제한이 10 RPM이라는 것을 알고 있다면, 요청 간격을 최소 6초로 유지하여 제한을 안전하게 지키세요. 이렇게 하면 대부분의 429 오류를 사전에 방지할 수 있습니다. Nano Banana Pro 429 오류 해결의 구체적인 전략은 속도 제한 수치를 조정하면 NB2에도 동일하게 적용됩니다.

지수 백오프(Exponential Backoff) 구현은 남은 429 오류에 대한 표준 해결책입니다. 첫 번째 실패 후 1초 지연으로 시작하여 각 후속 재시도마다 두 배로 늘리고(2초, 4초, 8초, 16초), 여러 클라이언트가 동시에 재시도할 때 발생하는 떼몰림(thundering herd) 문제를 방지하기 위해 작은 랜덤 지터를 추가합니다. RPM 관련 제한의 경우 최대 재시도 지연을 60초로 설정하고, RPD 기반 제한으로 보이는 경우 5~6회 재시도 후 포기를 고려하세요.

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 오류는 Gemini API 앞에 있는 리버스 프록시 또는 로드 밸런서가 요청을 처리하는 업스트림 서버에서 잘못된 응답을 받았다는 의미입니다. 서버 배포, 인프라 업데이트 또는 Google 데이터 센터 내의 일시적인 네트워크 문제 중에 발생할 수 있습니다. 핵심은 502 오류가 거의 항상 일시적이라는 것입니다. 일반적으로 별도의 조치 없이 5~15분 내에 해결됩니다. 30분 이상 지속되는 502 오류가 발생하면 Google Cloud Status Dashboard에서 Gemini API에 영향을 미치는 서비스 장애가 있는지 확인하세요.

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"
  }
}

Cherry Studio, Claude Code, Dify 같은 도구를 통해 Nano Banana 2에 접근하는 MCP(Model Context Protocol) 사용자의 경우, MCP 레이어가 자체 오류 래핑을 추가하기 때문에 이런 서버 측 오류가 혼란스럽게 나타날 수 있습니다. MCP 클라이언트에서 "upstream connection error"나 "model not responding" 같은 오류가 보이면, 근본 원인은 Gemini API의 502 또는 503일 가능성이 높습니다. 해결 방법은 동일합니다: 기다린 후 재시도하세요. Cherry Studio 사용자는 특히 서버 로그(보통 ~/.cherry-studio/logs/)를 확인하여 API의 실제 HTTP 상태 코드를 확인하는 것이 좋으며, 이를 통해 MCP 레이어 문제와 실제 API 장애를 구분할 수 있습니다.

502와 503 오류 모두 429 오류보다 더 긴 초기 지연으로 재시도 전략을 적용해야 합니다. 첫 번째 재시도에서 5초 지연으로 시작하고, 15초, 30초로 늘린 후 60초로 제한합니다. 이 오류들은 서버 측 부하를 나타내므로, 공격적인 재시도는 실제로 상황을 악화시킬 수 있습니다. 최대 3~4회 재시도 후 몇 분 후에 다시 시도하라는 사용자 친화적 오류 메시지로 우아하게 실패 처리하세요.

클라이언트 오류 해결 — 400 Bad Request, 403 Forbidden, IMAGE_SAFETY

클라이언트 오류는 위에서 다룬 서버 측 오류와 근본적으로 다릅니다. 재시도해도 해결되지 않는 요청의 문제를 나타내기 때문입니다. 동일한 잘못된 요청을 100번 보내면 동일한 오류를 100번 받게 됩니다. 다시 시도하기 전에 요청 페이로드, 자격 증명 또는 프롬프트에서 문제를 식별하고 수정해야 합니다.

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 프로젝트에서 Gemini API가 활성화되지 않았거나, 서비스 접근이 차단된 지리적 지역에 있는 것입니다. 수정은 특정 원인에 따라 다릅니다. 먼저, 간단한 텍스트 전용 요청(결제가 필요 없음)으로 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
        }
      ]
    }
  ]
}

이 경우 모델이 이미지를 생성하려 했지만 전달 전에 출력이 차단된 것입니다. 안전 차단된 생성에는 요금이 부과되지 않습니다. 이를 해결하려면 안전 필터를 트리거하는 콘텐츠를 피하도록 프롬프트를 수정하세요. "전문 사진", "에디토리얼 스타일", "깔끔한 일러스트" 같은 명시적 스타일 가이드를 추가하면 모델이 차단될 수 있는 콘텐츠를 피하는 데 도움이 됩니다. 여러 방식으로 해석될 수 있는 모호한 표현은 피하세요. 안전 시스템은 신중한 쪽으로 판단하기 때문입니다.

Nano Banana 2 속도 제한 설명 — 모든 등급과 제한

완전한 속도 제한 시스템을 이해하는 것은 오류가 발생하기 전에 예방하는 데 필수적입니다. Google은 Nano Banana 2 속도 제한을 네 가지 차원과 네 가지 등급에 걸쳐 구성하며, 각 조합에는 프로젝트가 만들 수 있는 요청 수를 결정하는 특정 숫자 제한이 있습니다. 이 모든 데이터는 2026년 3월 2일에 ai.google.dev/gemini-api/docs/rate-limits에서 직접 확인했습니다. 모든 Gemini 모델의 종합적인 분석은 Gemini API 등급별 속도 제한 완전 분석을 참고하세요.

네 가지 속도 제한 차원은 독립적으로 작동합니다. RPM(분당 요청 수)은 크기에 관계없이 API 호출 수를 제한합니다. TPM(분당 토큰 수)은 모든 요청에 걸친 총 토큰 처리량을 제한합니다. RPD(일당 요청 수)는 태평양 시간 자정에 초기화되는 일일 상한을 설정합니다. IPM(분당 이미지 수)은 구체적으로 이미지 생성 출력을 제한합니다. 이 중 하나의 제한에 도달해도 다른 것에 영향을 주지 않습니다. 예를 들어 RPM 용량이 남아 있더라도 해당 분의 IPM 할당량을 소진했을 수 있습니다.

속도 제한은 API 키가 아닌 Google Cloud 프로젝트 단위로 적용됩니다. 이는 많은 개발자가 놓치는 중요한 구분입니다. 동일한 프로젝트에서 여러 API 키를 생성하여 속도 제한을 곱하려 해도 작동하지 않습니다. 한 프로젝트의 모든 키는 동일한 속도 제한 풀을 공유합니다. 실질적으로 속도 제한을 늘리려면 별도의 Google Cloud 프로젝트를 만들어야 하지만, 이 접근 방식은 결제 관리의 복잡성이 있으며 특정 아키텍처 이유가 없는 한 일반적으로 권장되지 않습니다.

Google의 등급 시스템은 무료부터 Tier 1, Tier 2, Tier 3까지 진행됩니다. 무료 등급은 Nano Banana 2 이미지 생성을 전혀 지원하지 않으며, 결제를 활성화하지 않고 이미지를 생성하려 하면 즉시 429 오류가 발생합니다. Tier 1은 결제를 활성화하면 활성화되며 기본 이미지 생성 제한을 제공합니다. Tier 2는 지난 30일간 누적 지출 $250 이상이 필요하고, Tier 3는 $1,000 이상이 필요합니다. 각 등급 업그레이드는 네 가지 차원 모두에서 상당히 높은 제한을 제공합니다.

Tier 1 계정의 경우, 실질적으로 분당 약 10개의 이미지를 생성하고 하루에 최대 1,000개까지 생성할 수 있습니다. 애플리케이션이 실시간으로 사용자 요청을 처리하는 경우, 지속적으로 약 6초마다 하나의 이미지 요청을 처리하거나, 최대 10개의 동시 요청 후 필수 대기 기간을 갖는 짧은 버스트 처리가 가능합니다. 제품 카탈로그나 소셜 미디어 콘텐츠 같은 이미지 일괄 처리 애플리케이션의 경우, RPM보다는 하루 1,000건의 RPD 제한이 바인딩 제약이 되는 경우가 많습니다.

Batch API는 대량 작업에 대한 대안을 제공합니다. Nano Banana 2는 대기열 제한이 100만 토큰(Tier 1), 2억 5천만 토큰(Tier 2), 7억 5천만 토큰(Tier 3)인 배치 처리를 지원합니다. 배치 요청은 낮은 우선순위로 비동기 처리되지만 동기 요청과 동일한 RPM 제한을 받지 않습니다. 실시간 이미지 생성이 필요하지 않은 사용 사례라면, 등급 업그레이드 없이 처리량을 크게 높일 수 있습니다. laozhang.ai 같은 서비스는 이미지당 약 $0.05에 완화된 속도 제한으로 Nano Banana 2 접근을 제공하며, 여러 Google Cloud 프로젝트를 관리하거나 등급 업그레이드를 기다리는 복잡함 없이 더 높은 처리량이 필요한 개발자에게 실용적인 대안이 될 수 있습니다.

Nano Banana 2 프로덕션용 오류 처리 코드

강력한 오류 처리를 구현하려면 API 호출을 try-catch 블록으로 감싸는 것 이상이 필요합니다. 프로덕션 수준의 솔루션에는 지터를 포함한 지수 백오프, 실패 중인 서비스에 대한 과도한 요청을 방지하는 서킷 브레이커 패턴, 속도 제한 내에서 사전에 유지하기 위한 요청 큐잉이 포함되어야 합니다. 아래는 Nano Banana 2 통합에 맞게 수정할 수 있는 Python과 TypeScript의 완전한 구현입니다.

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 오류가 발생하기 전에 방지합니다. 둘째, 서킷 브레이커 패턴은 서버가 저하된 상태임을 감지(5회 연속 실패 후)하고 2분간 일시적으로 요청 전송을 중단하여 과부하를 악화시키는 대신 서버에 복구 시간을 제공합니다. 셋째, 지터를 포함한 지수 백오프 전략은 재시도 간 점진적으로 더 긴 지연을 사용하면서 여러 클라이언트가 동시에 재시도하는 것을 방지하기 위한 무작위성을 추가합니다.

오류가 계속 발생할 때 — 대안과 비용 최적화

위의 모든 오류 처리 전략을 구현했는데도 여전히 정기적으로 속도 제한에 도달한다면, 문제는 기술적이라기보다 아키텍처적일 가능성이 높습니다. 현재 등급의 용량을 초과한 것이며, 세 가지 실용적인 경로가 있습니다: Google Cloud 등급 업그레이드, 요청 패턴 최적화, 더 높은 제한을 제공하는 API 프록시 서비스 사용입니다.

등급 업그레이드는 가장 직접적인 해결책이지만 Google의 지출 기준을 충족해야 합니다. Tier 1에서 Tier 2로 이동하려면 30일간 누적 API 지출 $250이 필요하며, RPM이 10에서 30으로 3배, RPD가 1,000에서 5,000으로 5배 증가합니다. 많은 프로덕션 애플리케이션에 Tier 2 제한이면 충분합니다. Tier 3(30일간 $1,000 이상 지출)는 모든 것을 다시 두 배로 늘려 60 RPM과 10,000 RPD를 제공하며, 상당한 워크로드를 처리합니다. 지출 기준을 충족하면 전환이 자동으로 이루어지며, 신청 절차나 수동 승인이 필요하지 않습니다.

요청 패턴 최적화는 종종 등급 업그레이드의 필요성을 지연시키거나 없앨 수 있습니다. RPM 제한 바로 아래에서 안정적인 속도로 이미지 생성 작업을 일괄 처리하고 처리하는 요청 큐 구현을 고려하세요. 동일한 프롬프트에 대해 같은 이미지를 두 번 생성하지 않도록 생성된 이미지를 캐시하세요. 시간에 민감하지 않은 워크로드에는 표준 RPM 제한 밖에서 작동하는 Batch API를 사용하세요. 여러 해상도로 이미지를 생성하는 경우, 미리보기용으로 512px(이미지당 $0.045)부터 시작하고 확정된 선택에 대해서만 더 높은 해상도를 생성하세요.

API 프록시 서비스는 더 높은 속도 제한과 잠재적 비용 절감을 결합하는 세 번째 경로를 제공합니다. laozhang.ai 같은 서비스는 속도 제한 제약 없이 이미지당 약 $0.05에 Nano Banana 2 접근을 제공하며, 이는 1K 해상도 등급에서 Google 직접 가격($0.067)과 경쟁력이 있고 더 높은 해상도보다 상당히 저렴합니다. 가장 저렴한 Nano Banana 2 API 대안에 대해서는 모든 주요 제공업체를 비교하는 별도의 글이 있습니다. 프록시 서비스의 절충점은 네트워크 홉 추가와 제3자 제공업체에 대한 종속성이므로, 중요하지 않은 워크로드나 기본 Google Cloud 할당량이 소진되었을 때의 대체 방안으로 가장 적합합니다.

1K 해상도로 하루 1,000개 이미지를 생성하는 실질적인 비용 비교입니다:

Google 가격은 모든 등급에서 동일합니다. 등급은 이미지당 비용이 아닌 속도 제한에만 영향을 미칩니다. 이는 등급 업그레이드의 가치가 순전히 처리량 용량에 관한 것이지 단위 경제학이 아니라는 의미입니다. 비용이 주요 관심사이고 프록시 서비스에 만족한다면, 이미지당 약 25% 절감과 사실상 무제한 속도 제한을 얻을 수 있습니다. 관련 문서는 docs.laozhang.ai에서, 이미지 생성 테스트는 images.laozhang.ai에서 할 수 있습니다.

자주 묻는 질문

Nano Banana 2에서 429 오류를 어떻게 해결하나요?

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, 1,000 RPD, 10 IPM을 허용합니다. Tier 2(30일간 $250 이상 지출)는 30 RPM, 10M TPM, 5,000 RPD, 30 IPM을 허용합니다. Tier 3($1,000 이상 지출)는 60 RPM, 20M TPM, 10,000 RPD, 60 IPM을 허용합니다. 무료 등급은 이미지 생성을 지원하지 않습니다. 이 제한은 API 키가 아닌 프로젝트 단위이며, 2026년 3월 2일에 ai.google.dev에서 확인했습니다.

Nano Banana 2가 계속 502 오류를 주는 이유는 무엇인가요?

502 Bad Gateway 오류는 코드가 아닌 Google 서버의 문제를 나타냅니다. 이 오류는 보통 515분 내에 해결됩니다. 피크 사용 시간(10:0014:00 UTC)에 가장 흔합니다. 5초 초기 지연으로 시작하여 30~60초까지 늘리는 재시도 로직을 구현하세요. 30분 이상 502 오류가 지속되면 Google Cloud Status Dashboard에서 서비스 장애를 확인하세요. 실패한 502 요청에는 요금이 부과되지 않습니다.

Nano Banana 2는 무료로 사용할 수 있나요?

Nano Banana 2 텍스트 전용 요청은 무료 등급에서 사용 가능하지만, 이미지 생성은 결제 활성화(Tier 1 이상)가 필요합니다. NB2 이미지 생성에는 무료 등급이 없습니다. 이미지당 비용은 $0.045(512px)에서 $0.151(4K 해상도)까지이며, 입력 토큰은 100만 개당 $0.25, 이미지 출력 토큰은 100만 개당 $60입니다(2026년 3월 2일 Google 공식 가격 페이지에서 확인).

Nano Banana 2의 thought_signature 오류란 무엇인가요?

thought_signature 오류(400 Bad Request)는 다중 턴 대화에서 모델의 이전 응답에 포함된 thought_signature를 포함하지 않을 때 발생합니다. 사고 가시성을 "off"로 설정해도 NB2는 여전히 사고 토큰을 생성하고 후속 턴에서 반드시 전달해야 하는 서명을 포함합니다. API 응답에서 thought_signature 필드를 추출하여 다음 요청의 generation_config에 포함하면 이 오류가 해결됩니다.

오류 면에서 Nano Banana 2와 Pro는 어떻게 다른가요?

Nano Banana 2와 Pro는 동일한 오류 코드(429, 502, 503, 400, 403, IMAGE_SAFETY)를 공유하지만 속도 제한과 가격이 다릅니다. NB2는 토큰당 50~87% 저렴하지만 미리보기 모델로서 더 엄격한 속도 제한을 적용받습니다. NB2 입력은 100만 개당 $0.25, Pro는 $2.00이며, NB2 출력은 100만 개당 $60, Pro는 $120입니다. 두 모델 모두 무료 등급 이미지 생성이 없습니다. 오류 복원력 면에서 Pro는 비미리보기 상태 덕분에 동일 등급에서 약간 더 관대한 제한을 가질 수 있습니다.