Catatan Penulis: Analisis mendalam tentang error overloaded dan service unavailable pada Gemini Nano Banana Pro API, mencakup penyebab error, pola waktu, solusi praktis, dan praktik terbaik di lingkungan produksi.
Pada dini hari tanggal 16 Januari 2026 pukul 00:18, banyak pengembang melaporkan bahwa Gemini Nano Banana Pro API (nama model gemini-3-pro-image-preview) mengalami error 「The model is overloaded. Please try again later.」 atau bahkan 「The service is currently unavailable.」. Ini bukan masalah pada kode kamu, melainkan kegagalan sistemik yang disebabkan oleh hambatan kapasitas komputasi di sisi server Google.
Nilai Inti: Setelah membaca artikel ini, kamu akan memahami penyebab mendasar, pola waktu, dan mekanisme teknis dari kedua jenis error tersebut, menguasai 5 solusi praktis, dan belajar membangun strategi toleransi kesalahan tingkat produksi.
Poin Inti Error Gemini Nano Banana Pro API
| Poin | Penjelasan | Dampak |
|---|---|---|
| Error 503 Overloaded | Sumber daya komputasi server tidak mencukupi, bukan masalah kode | 45% panggilan API akan gagal selama jam sibuk |
| Error 503 vs 429 | 503 adalah masalah kapasitas, 429 adalah batas kecepatan | Pemulihan 503 butuh 30-120 menit, 429 hanya butuh 1-5 menit |
| Batasan Model Pratinjau | Seri Gemini 3 masih dalam tahap pratinjau | Sumber daya terbatas, manajemen kapasitas dinamis tidak stabil |
| Pola Waktu | Tingkat kegagalan tertinggi pada dini hari dan jam sibuk malam hari | Perlu menghindari jam sibuk atau menerapkan strategi fallback |
| Lonjakan Waktu Respons | Normal 20-40 detik, saat error bisa mencapai 60-100+ detik | Perlu mengatur waktu timeout yang lebih lama (120 detik+) |
Penjelasan Detail Error Gemini Nano Banana Pro
Apa itu Nano Banana Pro?
Gemini Nano Banana Pro adalah model penghasil gambar kualitas tertinggi dari Google, dengan nama model API gemini-2.0-flash-preview-image-generation atau gemini-3-pro-image-preview. Sebagai model unggulan dalam seri Gemini 3 untuk pembuatan gambar, model ini secara signifikan lebih unggul dalam hal kualitas gambar, detail, dan perenderan teks dibandingkan Gemini 2.5 Flash Image, namun karena itulah ia menghadapi hambatan sumber daya komputasi yang lebih parah.
Mengapa sering terjadi error?
Berdasarkan data diskusi di forum pengembang Google AI, masalah error pada Nano Banana Pro mulai sering muncul sejak paruh kedua tahun 2025 dan belum sepenuhnya teratasi hingga awal tahun 2026. Penyebab utamanya meliputi:
- Batasan Sumber Daya Tahap Pratinjau: Seri model Gemini 3 masih dalam tahap Pre-GA (General Availability), sehingga Google mengalokasikan sumber daya komputasi yang terbatas.
- Manajemen Kapasitas Dinamis: Bahkan jika kamu belum mencapai batas kecepatan (Rate Limit), sistem mungkin mengembalikan error 503 karena beban keseluruhan sistem yang terlalu tinggi.
- Kompetisi Pengguna Global: Semua pengembang berbagi kumpulan sumber daya komputasi yang sama, di mana permintaan pada jam sibuk jauh melampaui pasokan.
- Komputasi Model yang Intensif: Pembuatan gambar berkualitas tinggi membutuhkan komputasi GPU yang besar, dengan satu permintaan memakan waktu 20-40 detik, jauh lebih lama dibanding model teks.
Perbedaan Error 503 vs 429
| Jenis Error | Kode Status HTTP | Pesan Error | Penyebab Dasar | Waktu Pemulihan | Persentase |
|---|---|---|---|---|---|
| Overloaded | 503 | The model is overloaded |
Kapasitas komputasi server tidak cukup | 30-120 menit | Sekitar 25% |
| Rate Limit | 429 | RESOURCE_EXHAUSTED |
Melampaui kuota pengguna (RPM/TPM/RPD) | 1-5 menit | Sekitar 70% |
| Unavailable | 503 | Service unavailable |
Kegagalan sistemik atau pemeliharaan | Tidak pasti (bisa berjam-jam) | Sekitar 5% |
Analisis Pola Waktu Error Gemini Nano Banana Pro
Waktu Puncak Gangguan
Berdasarkan data laporan dari banyak pengembang, gangguan pada API Nano Banana Pro memiliki pola waktu yang jelas:
Waktu Risiko Tinggi (WIB/Waktu Beijing):
- 00:00 – 02:00: Jam kerja pantai barat AS (08:00-10:00 PST), puncak pengembang Eropa dan Amerika.
- 09:00 – 11:00: Jam mulai kerja Tiongkok Daratan, puncak pengembang Asia.
- 20:00 – 23:00: Puncak malam Tiongkok Daratan + tumpang tindih waktu sore Eropa.
Waktu Relatif Stabil:
- 03:00 – 08:00: Waktu dengan pengguna global paling sedikit.
- 14:00 – 17:00: Sore hari di Tiongkok + larut malam di AS, beban lebih rendah.
Verifikasi Kasus: Gangguan skala besar pada 16 Januari 2026 pukul 00:18 dini hari, tepat saat jam masuk kerja pantai barat AS (15 Januari 08:18 PST), membuktikan keakuratan pola waktu ini.
5 Cara Mengatasi Error Gemini Nano Banana Pro
Metode 1: Terapkan Strategi Retry Exponential Backoff
Ini adalah solusi paling mendasar untuk menangani error 503. Berikut adalah logika retry yang direkomendasikan:
import time
import random
from openai import OpenAI
client = OpenAI(
api_key="YOUR_API_KEY",
base_url="https://vip.apiyi.com/v1"
)
def generate_image_with_retry(
prompt: str,
model: str = "gemini-3-pro-image-preview",
max_retries: int = 5,
initial_delay: int = 10
):
"""
Fungsi pembuatan gambar dengan exponential backoff
"""
for attempt in range(max_retries):
try:
response = client.images.generate(
model=model,
prompt=prompt,
timeout=120 # Tambah waktu timeout
)
return response
except Exception as e:
error_msg = str(e)
# Error 503: Retry dengan exponential backoff
if "overloaded" in error_msg.lower() or "503" in error_msg:
if attempt < max_retries - 1:
delay = initial_delay * (2 ** attempt) + random.uniform(0, 5)
print(f"⚠️ Model overload, {delay:.1f} detik lagi dicoba ulang (percobaan {attempt + 1}/{max_retries})")
time.sleep(delay)
continue
else:
raise Exception("❌ Mencapai jumlah retry maksimum, model terus-menerus overload")
# Error 429: Tunggu sebentar lalu coba lagi
elif "429" in error_msg or "RESOURCE_EXHAUSTED" in error_msg:
print("⚠️ Batas rate limit, coba lagi dalam 60 detik")
time.sleep(60)
continue
# Error lainnya: Langsung lemparkan exception
else:
raise e
raise Exception("❌ Semua percobaan retry gagal")
# Contoh penggunaan
result = generate_image_with_retry(
prompt="A futuristic city at sunset, cyberpunk style",
max_retries=5
)
Lihat Kode Lengkap Level Produksi
import time
import random
from typing import Optional, Dict
from openai import OpenAI
from datetime import datetime, timedelta
class GeminiImageClient:
"""
Klien pembuatan gambar Gemini level produksi
Mendukung retry, fallback, dan monitoring
"""
def __init__(self, api_key: str, base_url: str = "https://vip.apiyi.com/v1"):
self.client = OpenAI(api_key=api_key, base_url=base_url)
self.error_log = []
self.success_count = 0
self.failure_count = 0
def generate_with_fallback(
self,
prompt: str,
primary_model: str = "gemini-3-pro-image-preview",
fallback_model: str = "gemini-2.5-flash-image",
max_retries: int = 3
) -> Dict:
"""
Pembuatan gambar dengan strategi fallback
"""
# Coba model utama
try:
result = self._generate_with_retry(prompt, primary_model, max_retries)
self.success_count += 1
return {
"success": True,
"model_used": primary_model,
"data": result
}
except Exception as e:
print(f"⚠️ Model utama {primary_model} gagal: {str(e)}")
# Fallback otomatis ke model cadangan
try:
print(f"🔄 Melakukan fallback ke model cadangan {fallback_model}")
result = self._generate_with_retry(prompt, fallback_model, max_retries)
self.success_count += 1
return {
"success": True,
"model_used": fallback_model,
"fallback": True,
"data": result
}
except Exception as fallback_error:
self.failure_count += 1
self.error_log.append({
"timestamp": datetime.now(),
"primary_error": str(e),
"fallback_error": str(fallback_error)
})
return {
"success": False,
"error": str(fallback_error)
}
def _generate_with_retry(self, prompt: str, model: str, max_retries: int):
"""Logika retry internal"""
for attempt in range(max_retries):
try:
response = self.client.images.generate(
model=model,
prompt=prompt,
timeout=120
)
return response
except Exception as e:
if attempt < max_retries - 1:
delay = 10 * (2 ** attempt) + random.uniform(0, 5)
time.sleep(delay)
else:
raise e
def get_stats(self) -> Dict:
"""Dapatkan data statistik"""
total = self.success_count + self.failure_count
success_rate = (self.success_count / total * 100) if total > 0 else 0
return {
"total_requests": total,
"success_count": self.success_count,
"failure_count": self.failure_count,
"success_rate": f"{success_rate:.2f}%",
"recent_errors": self.error_log[-5:]
}
# Contoh penggunaan
client = GeminiImageClient(api_key="YOUR_API_KEY")
result = client.generate_with_fallback(
prompt="A magical forest with glowing mushrooms",
primary_model="gemini-3-pro-image-preview",
fallback_model="gemini-2.5-flash-image"
)
if result["success"]:
print(f"✅ Generasi berhasil, menggunakan model: {result['model_used']}")
else:
print(f"❌ Generasi gagal: {result['error']}")
# Lihat statistik
print(client.get_stats())
Saran Teknis: Dalam lingkungan produksi nyata, disarankan untuk melakukan panggilan interface melalui platform APIYI (apiyi.com). Platform ini menyediakan API interface terpadu, mendukung Gemini 3 Pro dan berbagai model pembuatan gambar. Saat Nano Banana Pro overload, Anda dapat beralih cepat ke Gemini 2.5 Flash atau model cadangan lainnya untuk memastikan kontinuitas bisnis.
Metode 2: Tingkatkan Timeout dan Konfigurasi Request
Waktu respons normal Nano Banana Pro adalah 20-40 detik, tetapi saat overload bisa mencapai 60-100 detik atau lebih. Pengaturan timeout default 30 detik akan menyebabkan banyak kesalahan deteksi.
Konfigurasi yang Direkomendasikan:
from openai import OpenAI
client = OpenAI(
api_key="YOUR_API_KEY",
base_url="https://vip.apiyi.com/v1",
timeout=120, # Tingkatkan timeout global ke 120 detik
max_retries=3 # SDK retry otomatis 3 kali
)
# Atau tentukan dalam satu request
response = client.images.generate(
model="gemini-3-pro-image-preview",
prompt="Petunjuk Anda di sini",
timeout=150 # Timeout request tunggal 150 detik
)
Penjelasan Parameter Kunci:
timeout: Waktu tunggu maksimum untuk satu request, disarankan diatur ke 120-180 detik.max_retries: Jumlah retry otomatis di tingkat SDK, disarankan 2-3 kali.keep_alive: Menjaga koneksi tetap aktif untuk menghindari pemutusan pada request yang lama.
Metode 3: Hindari Waktu Puncak
Jika bisnis memungkinkan pemrosesan asinkron, menjadwalkan tugas berdasarkan pola waktu dapat meningkatkan tingkat keberhasilan secara signifikan:
Strategi Penjadwalan yang Direkomendasikan:
- Tugas prioritas tinggi: Ditempatkan pada pukul 03:00-08:00 atau 14:00-17:00 WIB.
- Tugas pembuatan massal: Gunakan antrean tugas untuk dieksekusi otomatis pada waktu sepi.
- Tugas real-time: Wajib menerapkan strategi fallback, tidak boleh bergantung pada satu model saja.
Contoh Penjadwalan Tugas Python:
from datetime import datetime
def is_peak_hour() -> bool:
"""Menentukan apakah saat ini waktu puncak (Waktu Beijing/WIB)"""
current_hour = datetime.now().hour
# Waktu puncak: 0-2, 9-11, 20-23
peak_hours = list(range(0, 3)) + list(range(9, 12)) + list(range(20, 24))
return current_hour in peak_hours
def smart_generate(prompt: str):
"""Generasi cerdas: Fallback otomatis di waktu puncak"""
if is_peak_hour():
print("⚠️ Saat ini waktu puncak, gunakan model cadangan")
model = "gemini-2.5-flash-image"
else:
model = "gemini-3-pro-image-preview"
return generate_image(prompt, model)
Metode 4: Terapkan Strategi Fallback Model
Google secara resmi menyarankan untuk beralih ke Gemini 2.5 Flash saat terjadi overload. Berikut adalah data perbandingannya:
| Indikator | Gemini 3 Pro (Nano Banana Pro) | Gemini 2.5 Flash Image |
|---|---|---|
| Kualitas Gambar | Tertinggi (9/10) | Luar Biasa (7.5/10) |
| Kecepatan Generasi | 20-40 detik | 10-20 detik |
| Stabilitas | Tingkat kegagalan waktu puncak 45% | Tingkat kegagalan waktu puncak <10% |
| Waktu Pemulihan 503 | 30-120 menit | 5-15 menit |
| Biaya API | Lebih Tinggi | Lebih Rendah |
Saran Solusi: Untuk skenario yang sensitif terhadap kualitas (poster pemasaran, foto produk, dll.), utamakan Gemini 3 Pro, jika gagal lakukan fallback ke 2.5 Flash. Untuk skenario konkurensi tinggi (konten UGC, prototipe cepat), langsung gunakan 2.5 Flash untuk meningkatkan stabilitas. Disarankan menggunakan platform APIYI (apiyi.com) untuk pengujian perbandingan model, platform ini mendukung pergantian model sekali klik serta menyediakan data perbandingan biaya dan kualitas.
Metode 5: Sistem Pemantauan dan Peringatan
Lingkungan produksi harus menerapkan pemantauan yang lengkap untuk mendeteksi dan merespons gangguan tepat waktu:
Indikator Pemantauan Kunci:
- Tingkat Keberhasilan: Tingkat keberhasilan dalam 5 menit / 1 jam / 24 jam terakhir.
- Waktu Respons: Waktu respons P50 / P95 / P99.
- Distribusi Error: Persentase error seperti 503 / 429 / 500.
- Jumlah Pemicu Fallback: Jumlah fallback yang disebabkan kegagalan model utama.
Implementasi Pemantauan Sederhana:
from collections import deque
from datetime import datetime
class APIMonitor:
"""Monitor panggilan API"""
def __init__(self, window_size: int = 100):
self.recent_calls = deque(maxlen=window_size)
self.error_counts = {"503": 0, "429": 0, "500": 0, "other": 0}
def log_call(self, success: bool, response_time: float, error_code: str = None):
"""Mencatat panggilan API"""
self.recent_calls.append({
"timestamp": datetime.now(),
"success": success,
"response_time": response_time,
"error_code": error_code
})
if not success and error_code:
if error_code in self.error_counts:
self.error_counts[error_code] += 1
else:
self.error_counts["other"] += 1
def get_success_rate(self) -> float:
"""Menghitung tingkat keberhasilan"""
if not self.recent_calls:
return 0.0
success_count = sum(1 for call in self.recent_calls if call["success"])
return success_count / len(self.recent_calls) * 100
def should_alert(self) -> bool:
"""Menentukan apakah perlu peringatan"""
success_rate = self.get_success_rate()
# Peringatan dipicu jika tingkat keberhasilan di bawah 70%
if success_rate < 70:
return True
# Peringatan dipicu jika error 503 melebihi 30%
total_errors = sum(self.error_counts.values())
if total_errors > 0 and self.error_counts["503"] / total_errors > 0.3:
return True
return False
# Contoh penggunaan
monitor = APIMonitor(window_size=100)
# Catat setelah setiap panggilan
start_time = time.time()
try:
result = client.images.generate(...)
response_time = time.time() - start_time
monitor.log_call(success=True, response_time=response_time)
except Exception as e:
response_time = time.time() - start_time
error_code = "503" if "overload" in str(e) else "other"
monitor.log_call(success=False, response_time=response_time, error_code=error_code)
# Periksa peringatan secara berkala
if monitor.should_alert():
print(f"🚨 Peringatan: Tingkat keberhasilan API turun menjadi {monitor.get_success_rate():.2f}%")
layout: post
title: Penjelasan Detail Kuota dan Batas Kecepatan Gemini API
Penyesuaian Kuota Desember 2025
Pada 7 Desember 2025, Google melakukan penyesuaian pada batas kuota Gemini API, yang menyebabkan banyak pengembang mengalami error 429 yang tidak terduga.
Standar Kuota Saat Ini (Januari 2026):
| Dimensi Kuota | Versi Gratis (Free Tier) | Versi Berbayar Tier 1 | Keterangan |
|---|---|---|---|
| RPM (Permintaan per menit) | 5-15 (tergantung model) | 150-300 | Batasan Gemini 3 Pro lebih ketat |
| TPM (Token per menit) | 32.000 | 4.000.000 | Berlaku untuk model teks |
| RPD (Permintaan per hari) | 1.500 | 10.000+ | Gabungan kumpulan kuota (shared pool) |
| IPM (Gambar per menit) | 5-10 | 50-100 | Khusus untuk model pembuatan gambar |
Hal Penting yang Perlu Diperhatikan:
- Batasan kuota didasarkan pada level Google Cloud Project, bukan berdasarkan masing-masing API Key.
- Membuat banyak API Key dalam satu proyek yang sama tidak akan meningkatkan kuota.
- Melebihi batas pada dimensi mana pun akan memicu error 429.
- Menggunakan algoritma Token Bucket untuk penegakan aturan, sehingga lonjakan trafik yang tiba-tiba akan langsung dibatasi.
Optimasi Biaya: Bagi proyek yang sensitif terhadap anggaran, Anda bisa mempertimbangkan untuk memanggil Gemini API melalui platform APIYI (apiyi.com). Platform ini menawarkan metode pembayaran sesuai pemakaian (pay-as-you-go) yang fleksibel tanpa perlu berlangganan Google Cloud, sangat cocok untuk tim kecil, menengah, maupun pengembang perorangan untuk pengujian cepat dan penerapan skala kecil.
Pertanyaan yang Sering Diajukan (FAQ)
Q1: Bagaimana cara membedakan error 503 overloaded dan 429 rate limit?
Perbedaan keduanya terletak pada penyebab utama dan waktu pemulihannya:
503 Overloaded:
- Pesan Error:
The model is overloaded. Please try again later. - Kode Status HTTP: 503 Service Unavailable
- Penyebab Utama: Sumber daya komputasi di sisi server Google sedang tidak mencukupi, tidak ada hubungannya dengan kuota Anda.
- Waktu Pemulihan: 30-120 menit (Gemini 3 Pro), 5-15 menit (Gemini 2.5 Flash).
- Strategi Menghadapi: Gunakan exponential backoff untuk mencoba lagi, beralih ke model cadangan, atau hindari jam sibuk.
429 Rate Limit:
- Pesan Error:
RESOURCE_EXHAUSTEDatauRate limit exceeded - Kode Status HTTP: 429 Too Many Requests
- Penyebab Utama: Panggilan API Anda telah melampaui batas kuota (RPM/TPM/RPD/IPM).
- Waktu Pemulihan: 1-5 menit (kumpulan kuota akan pulih secara otomatis).
- Strategi Menghadapi: Kurangi frekuensi permintaan, tingkatkan ke versi berbayar, atau ajukan permohonan peningkatan kuota.
Cara Cepat Memastikannya: Periksa penggunaan kuota di Google AI Studio. Jika sudah mendekati atau mencapai ambang batas, itu adalah error 429. Jika tidak, maka itu adalah error 503.
Q2: Mengapa terjadi gangguan skala besar pada pukul 00:18 dini hari?
Gangguan besar pada pukul 00:18 WIB (Waktu Indonesia Barat) tanggal 16 Januari 2026 bertepatan dengan pukul 08:18 PST di Pantai Barat Amerika Serikat, yang merupakan jam dimulainya hari kerja di sana.
Analisis Pola Waktu:
- Pengembang di Pantai Barat AS (Silicon Valley) mulai bekerja pukul 08:00-10:00 PST, yang setara dengan pukul 23:00-01:00 WIB.
- Puncak aktivitas pengembang di Eropa terjadi pada pukul 14:00-18:00 CET, setara dengan pukul 20:00-00:00 WIB.
- Pengembang di China/Asia juga memiliki puncak aktivitas pada pukul 09:00-11:00 dan 20:00-23:00 CST (selisih satu jam dengan WIB).
Pertemuan ketiga zona waktu ini menyebabkan beban pada Nano Banana Pro API jauh melampaui kapasitasnya, sehingga memicu error 503 secara massal.
Saran: Jika bisnis Anda menyasar pengguna di Asia, Anda bisa menjadwalkan tugas batch pada pukul 03:00-08:00 WIB (saat tengah malam di AS dan dini hari di Eropa), di mana beban global berada pada titik terendah.
Q3: Bagaimana cara memilih model untuk lingkungan produksi?
Pilihlah strategi model yang sesuai dengan kebutuhan bisnis Anda:
Strategi 1: Mengutamakan Kualitas (Pemasaran, Gambar Produk)
- Model Utama: Gemini 3 Pro Image Preview (Nano Banana Pro)
- Model Cadangan: Gemini 2.5 Flash Image
- Implementasi: Jika model utama gagal 3 kali, otomatis turun (fallback) ke model cadangan.
- Estimasi Tingkat Keberhasilan: 92-95% (termasuk fallback).
Strategi 2: Mengutamakan Stabilitas (UGC, Konkurensi Tinggi)
- Model Utama: Gemini 2.5 Flash Image
- Model Cadangan: Model penghasil gambar lainnya (DALL-E 3, Stable Diffusion XL)
- Implementasi: Gunakan 2.5 Flash secara langsung, beralih ke model pihak ketiga jika terjadi gangguan.
- Estimasi Tingkat Keberhasilan: 95-98%.
Strategi 3: Mengutamakan Biaya (Pengujian, Prototipe)
- Gunakan Gemini 2.5 Flash versi gratis.
- Siap menerima error 429 dan 503 sesekali.
- Tidak perlu mengimplementasikan logika toleransi kesalahan yang rumit.
Solusi yang Direkomendasikan: Gunakan platform APIYI (apiyi.com) untuk menguji efektivitas dan biaya berbagai model dengan cepat. Platform ini menyediakan antarmuka terpadu untuk memanggil berbagai model penghasil gambar, sehingga memudahkan perbandingan dan peralihan antar model.
Ringkasan
Poin-poin inti mengenai error pada Gemini Nano Banana Pro API:
- 503 Overloaded adalah masalah sistemik: Ini tidak ada hubungannya dengan kode kamu, melainkan disebabkan oleh kurangnya sumber daya komputasi di sisi server Google. Pada jam sibuk, sekitar 45% pemanggilan API bisa mengalami kegagalan.
- Pola waktu yang jelas: Waktu Beijing pukul 00:00-02:00, 09:00-11:00, dan 20:00-23:00 adalah periode risiko tinggi. Sebaiknya hindari jam-jam tersebut atau siapkan strategi fallback.
- Implementasi toleransi kesalahan sangat krusial: Kamu wajib menerapkan tiga lapis perlindungan: retry dengan exponential backoff, menambah durasi timeout (120 detik+), dan penurunan model atau fallback (gunakan 2.5 Flash sebagai cadangan).
- Monitoring dan Alerting: Di lingkungan produksi, kamu harus memantau success rate, waktu respons, dan distribusi error agar bisa mendeteksi serta merespons gangguan dengan cepat.
- Pahami batasan kuota: Error 429 berkaitan dengan kuota API milikmu, sedangkan error 503 berkaitan dengan beban server Google secara keseluruhan. Strategi penanganan untuk keduanya berbeda.
Sebagai model dalam tahap pratinjau (preview), masalah stabilitas pada Nano Banana Pro sulit diselesaikan sepenuhnya dalam waktu singkat. Kami menyarankan untuk memvalidasi kebutuhan pembuatan gambar kamu melalui APIYI apiyi.com. Platform ini menyediakan kuota gratis dan antarmuka terpadu untuk berbagai model, mendukung model image generation populer seperti Gemini 3 Pro, Gemini 2.5 Flash, hingga DALL-E 3 untuk menjaga keberlanjutan bisnis kamu.
📚 Referensi
⚠️ Catatan Format Link: Semua tautan luar menggunakan format
Nama Sumber: domain.comagar mudah disalin tetapi tidak bisa diklik langsung, guna menjaga kualitas SEO.
-
Nano Banana Errors & Troubleshooting Guide: Panduan lengkap referensi error
- Link:
www.aifreeapi.com/en/posts/nano-banana-errors-troubleshooting-guide - Keterangan: Mencakup solusi lengkap untuk semua kode error Nano Banana Pro seperti 429, 502, 403, 500, dll.
- Link:
-
Google AI Developers Forum: Diskusi error Gemini 3 Pro overloaded
- Link:
discuss.ai.google.dev/t/gemini-3-pro-nano-banana-tier-1-4k-image-503-unavailable-error-the-model-is-overloaded/110232 - Keterangan: Diskusi real-time dan berbagi pengalaman dari komunitas pengembang mengenai error 503.
- Link:
-
Dokumentasi Resmi Gemini API Rate Limits: Penjelasan kuota dan batasan kecepatan
- Link:
ai.google.dev/gemini-api/docs/rate-limits - Keterangan: Dokumentasi resmi kuota API dari Google, berisi rincian lengkap mengenai RPM/TPM/RPD/IPM.
- Link:
-
Gemini 3 Pro Image Preview Error Codes: Panduan lengkap kode error
- Link:
www.aifreeapi.com/en/posts/gemini-3-pro-image-preview-error-codes - Keterangan: Panduan troubleshooting dan solusi untuk semua kode error Gemini 3 Pro tahun 2025-2026.
- Link:
Penulis: Tim Teknis
Diskusi Teknis: Silakan diskusikan pengalaman kamu menggunakan Gemini API di kolom komentar. Untuk dokumentasi troubleshooting lebih lanjut, kunjungi komunitas teknis APIYI apiyi.com.
