Cara Menggunakan Google Nano Banana 2 API

Membangun aplikasi dengan pembuatan gambar AI terasa seperti sihir—sampai Anda menemui kesulitan dokumentasi API yang kompleks, masalah autentikasi, dan mimpi buruk debugging. Anda telah melihat apa yang bisa dilakukan Nano Banana 2: gambar menakjubkan yang dihasilkan dari prompt teks, output kualitas Pro dengan kecepatan Flash, dan fitur seperti konsistensi subjek yang memungkinkan alur kerja multi-gambar. Tapi bagaimana dengan mengintegrasikannya ke dalam codebase Anda? Di situlah kebanyakan developer mengalami kesulitan.

Anda mungkin sudah mencoba menyelami dokumentasi Google, menyusun alur autentikasi, dan menguji permintaan secara manual di CLI. Mungkin Anda sudah menghabiskan kuota API untuk men-debug permintaan yang salah format atau bertanya-tanya mengapa gambar Anda selalu kembali buram. Kenyataannya, mengintegrasikan API baru, terutama yang sekuat Nano Banana 2, membutuhkan lebih dari sekadar membaca dokumen. Anda memerlukan alur kerja yang memungkinkan Anda menguji dengan cepat, mengulang prompt, dan mengelola panggilan API Anda secara efisien.

Dalam panduan ini, kami akan membahas semua yang Anda perlukan untuk mengintegrasikan Nano Banana 2 ke dalam aplikasi Anda, mulai dari menyiapkan proyek Google Cloud Anda hingga menulis kode siap produksi dalam Python dan JavaScript. Tapi inilah yang membuat panduan ini berbeda: kami akan menunjukkan cara menguji dan men-debug setiap langkah menggunakan Apidog, sehingga Anda tidak hanya menyalin kode, Anda sedang membangun alur kerja yang dapat Anda pelihara dan skalakan.

Prasyarat

Sebelum memulai, pastikan Anda memiliki:

• Akun Google Cloud (atau daftar di cloud.google.com)
• Pemahaman dasar tentang REST API
• Python 3.8+ atau Node.js 18+ terinstal
• Klien API seperti Apidog untuk pengujian

Panduan ini mengasumsikan Anda terbiasa dengan membuat permintaan HTTP dan menangani data JSON. Jika Anda baru mengenal API, lihat Panduan Pengujian API kami untuk dasar-dasarnya.

Menyiapkan Proyek Google Cloud Anda

Untuk menggunakan Nano Banana 2 API, Anda memerlukan proyek Google Cloud dengan Generative Language API diaktifkan.

Langkah 1: Membuat Proyek Baru

1. Buka Google Cloud Console
2. Klik "Pilih proyek" → "Proyek Baru"
3. Masukkan nama proyek (misalnya, "nano-banana-image-gen")
4. Klik "Buat"
5. Tunggu hingga proyek dibuat

Langkah 2: Mengkonfigurasi Akses API

1. Buka "API & Layanan" → "Kredensial"
2. Klik "Buat Kredensial" → "Kunci API"
3. Salin kunci API Anda (Anda akan membutuhkannya nanti)

Tips Pro:

Mendapatkan Kunci API Anda

Ada dua cara untuk mendapatkan akses API:

Opsi 1: Google Cloud Console (Direkomendasikan untuk Produksi)

Ikuti langkah-langkah di atas—kunci API yang Anda buat adalah kredensial akses Anda.

Opsi 2: Google AI Studio (Direkomendasikan untuk Pengembangan)

1. Buka Google AI Studio
2. Masuk dengan akun Google Anda
3. Klik "Dapatkan Kunci API" di navigasi
4. Klik "Buat Kunci API" (atau pilih proyek yang sudah ada)
5. Salin kunci API Anda

Kunci AI Studio sangat bagus untuk pengembangan dan pengujian. Untuk produksi, gunakan kunci Google Cloud Console untuk pengelolaan dan keamanan yang lebih baik.

Permintaan API Pertama Anda

Mari kita buat permintaan pembuatan gambar sederhana untuk memverifikasi semuanya berfungsi.

Menggunakan cURL

curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp-image-generation:predict?key=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Karakter pisang lucu memakai kacamata hitam, gaya kartun yang menyenangkan",
    "number_of_images": 1
  }'

Memahami Respons

{
  "predictions": [
    {
      "image": {
        "mimeType": "image/png",
        "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
      },
      "generatedImageId": "img_abc123xyz",
      "metadata": {
        "prompt": "Karakter pisang lucu memakai kacamata hitam, gaya kartun yang menyenangkan",
        "seed": 12345,
        "finishReason": "SUCCESS"
      }
    }
  ],
  "metadata": {
    "modelVersion": "gemini-3.1-flash-image-preview",
    "processingTimeMs": 1250,
    "contentAuthenticity": {
      "synthID": "enabled",
      "c2pa": "enabled"
    }
  }
}

Kolom `data` berisi gambar PNG yang dienkode base64. Anda perlu mendekodenya untuk menyimpan atau menampilkan gambar.

Integrasi Python

Berikut cara mengintegrasikan Nano Banana 2 ke dalam aplikasi Python Anda:

Menginstal Pustaka Klien

pip install google-generativeai

Pembuatan Gambar Dasar

import google.generativeai as genai
import base64
import os

# Konfigurasi API dengan kunci Anda
genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))

# Buat model
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Hasilkan gambar
response = model.generate_images(
    prompt="Kantor minimalis modern dengan pencahayaan alami, tanaman dalam ruangan, meja berdiri, kualitas 4k",
    number_of_images=1
)

# Simpan gambar
if response.generated_images:
    image_data = response.generated_images[0].image_bytes
    with open("output_image.png", "wb") as f:
        f.write(image_data)
    print("Gambar disimpan ke output_image.png")

Pembuatan Gambar Lanjutan dengan Parameter

import google.generativeai as genai
from PIL import Image
import io

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))

model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Hasilkan dengan parameter lanjutan
response = model.generate_images(
    prompt="Pemandangan kota futuristik di malam hari dengan lampu neon, mobil terbang, estetika cyberpunk",
    number_of_images=1,
    aspect_ratio="16:9",
    negative_prompt="buram, kualitas rendah, terdistorsi, jelek",
    safety_filter_level="block_medium_and_above"
)

# Memproses respons
for idx, generated_image in enumerate(response.generated_images):
    # Konversi ke Gambar PIL
    image = Image.open(io.BytesIO(generated_image.image_bytes))

    # Simpan dengan nama kustom
    image.save(f"generated_image_{idx}.png")

    # Akses metadata
    print(f"Gambar {idx}: {generated_image.finish_reason}")
    print(f"Seed: {generated_image.seed}")

Pembuatan Gambar Batch

import google.generativeai as genai
import os

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Hasilkan banyak gambar sekaligus
prompts = [
    "Mobil sport merah di jalan pegunungan",
    "Interior kafe yang nyaman",
    "Desain kamar tidur minimalis",
    "Matahari terbenam di pantai tropis"
]

# Hasilkan semua gambar
for idx, prompt in enumerate(prompts):
    response = model.generate_images(
        prompt=prompt,
        number_of_images=1,
        aspect_ratio="16:9"
    )

    if response.generated_images:
        image_data = response.generated_images[0].image_bytes
        with open(f"image_{idx + 1}.png", "wb") as f:
            f.write(image_data)
        print(f"Dihasilkan: image_{idx + 1}.png")

Contoh Konsistensi Karakter

import google.generativeai as genai

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Deskripsi karakter dasar
base_character = "Robot kartun ramah dengan tubuh bulat, mata biru, antena di kepala, skema warna putih dan biru muda"

# Hasilkan karakter dasar (perhatikan seed untuk konsistensi)
response1 = model.generate_images(
    prompt=base_character + ", tampak depan, pose berdiri",
    number_of_images=1,
    seed=42  # Penting: perhatikan seed ini
)

base_seed = response1.generated_images[0].seed
print(f"Seed karakter dasar: {base_seed}")

# Hasilkan variasi menggunakan seed yang sama
poses = [
    "pose duduk",
    "melambai tangan",
    "memegang bola",
    "berjalan"
]

for pose in poses:
    response = model.generate_images(
        prompt=f"{base_character}, {pose}, karakter yang sama dengan seed {base_seed}",
        number_of_images=1,
        seed=base_seed  # Seed yang sama menjaga konsistensi
    )

    if response.generated_images:
        filename = f"robot_{pose.replace(' ', '_')}.png"
        with open(filename, "wb") as f:
            f.write(response.generated_images[0].image_bytes)
        print(f"Dihasilkan: {filename}")

Integrasi JavaScript/Node.js

Menginstal Pustaka Klien

npm install @google/generative-ai

Pembuatan Gambar Dasar

const { GoogleGenerativeAI } = require("@google/generative-ai");
const fs = require("fs");
const path = require("path");

// Inisialisasi dengan kunci API
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

async function generateImage() {
  // Dapatkan model
  const model = genAI.getGenerativeModel({
    model: "gemini-3.1-flash-image-preview",
  });

  // Hasilkan gambar
  const result = await model.generateImages({
    prompt: "Matahari terbenam yang indah di atas laut dengan siluet pohon palem",
    numberOfImages: 1,
  });

  // Memproses respons
  if (result.generatedImages && result.generatedImages.length > 0) {
    const imageData = result.generatedImages[0].imageBytes;

    // Simpan ke berkas
    fs.writeFileSync("sunset.png", Buffer.from(imageData, "base64"));
    console.log("Gambar disimpan ke sunset.png");

    // Catat metadata
    console.log("Seed:", result.generatedImages[0].seed);
    console.log("Finish Reason:", result.generatedImages[0].finishReason);
  }
}

generateImage().catch(console.error);

Menangani Respons Base64

const { GoogleGenerativeAI } = require("@google/generative-ai");
const fs = require("fs");

const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

async function generateAndProcessImage() {
  const model = genAI.getGenerativeModel({
    model: "gemini-3.1-flash-image-preview",
  });

  const result = await model.generateImages({
    prompt: "Foto kepala profesional seseorang dengan pakaian bisnis, pencahayaan studio",
    numberOfImages: 1,
    aspectRatio: "1:1",
    resolution: "1024x1024"
  });

  const generatedImage = result.generatedImages[0];

  // Dekode base64
  const imageBuffer = Buffer.from(generatedImage.imageBytes, "base64");

  // Simpan dengan metadata di nama file
  const filename = `portrait_${generatedImage.seed}.png`;
  fs.writeFileSync(filename, imageBuffer);

  return {
    filename,
    seed: generatedImage.seed,
    finishReason: generatedImage.finishReason
  };
}

generateAndProcessImage()
  .then(info => console.log("Dihasilkan:", info))
  .catch(err => console.error("Error:", err));

Contoh API REST Express.js

const express = require("express");
const { GoogleGenerativeAI } = require("@google/generative-ai");
const multer = require("multer");
const fs = require("fs");

const app = express();
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

app.use(express.json());

// Endpoint pembuatan gambar
app.post("/api/generate", async (req, res) => {
  try {
    const { prompt, aspect_ratio, negative_prompt, number_of_images } = req.body;

    const model = genAI.getGenerativeModel({
      model: "gemini-2.0-flash-exp-image-generation",
    });

    const result = await model.generateImages({
      prompt,
      numberOfImages: number_of_images || 1,
      aspectRatio: aspect_ratio || "1:1",
      negativePrompt: negative_prompt
    });

    // Konversi gambar ke base64 untuk respons
    const images = result.generatedImages.map((img, idx) => ({
      id: idx,
      seed: img.seed,
      finishReason: img.finishReason,
      data: img.imageBytes // Dikenkode Base64
    }));

    res.json({
      success: true,
      images,
      metadata: {
        modelVersion: result.response?.metadata?.modelVersion,
        processingTimeMs: result.response?.metadata?.processingTimeMs
      }
    });
  } catch (error) {
    console.error("Generation error:", error);
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// Endpoint pembuatan batch
app.post("/api/generate/batch", async (req, res) => {
  try {
    const { prompts } = req.body;
    const model = genAI.getGenerativeModel({
      model: "gemini-3.1-flash-image-preview",
    });

    const results = [];

    for (const prompt of prompts) {
      const result = await model.generateImages({
        prompt,
        numberOfImages: 1
      });

      results.push({
        prompt,
        seed: result.generatedImages[0]?.seed,
        success: !!result.generatedImages[0]
      });
    }

    res.json({ success: true, results });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

app.listen(3000, () => {
  console.log("Server berjalan di port 3000");
});

Parameter Lanjutan

Nano Banana 2 mendukung berbagai parameter untuk menyempurnakan pembuatan gambar Anda:

Referensi Parameter

Opsi Resolusi

# Resolusi yang tersedia
resolutions = [
    "512x512",    # Gambar mini, media sosial
    "768x768",    # Gambar web kecil
    "1024x1024",  # Persegi standar
    "1024x768",   # Lanskap 4:3
    "1280x720",   # Siap HD
    "1920x1080",  # Full HD
    "2048x2048",  # Kualitas tinggi
    "3840x2160"   # 4K
]

# Menggunakan resolusi spesifik
response = model.generate_images(
    prompt="Fotografi produk profesional jam tangan",
    resolution="2048x2048"
)

Rasio Aspek

aspect_ratios = [
    "1:1",    # Persegi (postingan Instagram)
    "4:3",    # Foto standar
    "16:9",   # Lanskap (YouTube, web)
    "9:16",   # Potret (Cerita, TikTok)
    "21:9",   # Ultra lebar
    "3:4",    # Potret standar
    "2:3"     # Foto potret
]

# Menggunakan rasio aspek spesifik
response = model.generate_images(
    prompt="Desain interior kantor modern",
    aspect_ratio="16:9"
)

Menangani Respons

Mengurai Struktur Respons

import google.generativeai as genai

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

response = model.generate_images(
    prompt="Kastil fantasi di atas gunung",
    number_of_images=2
)

# Mengakses prediksi (gambar yang dihasilkan)
for idx, image in enumerate(response.generated_images):
    print(f"Gambar {idx + 1}:")
    print(f"  - Seed: {image.seed}")
    print(f"  - Finish Reason: {image.finish_reason}")
    print(f"  - Panjang Byte Gambar: {len(image.image_bytes)}")

# Mengakses metadata
print("\nMetadata:")
print(f"  - Versi Model: {response.response.metadata.model_version}")
print(f"  - Waktu Pemrosesan: {response.response.metadata.processing_time_ms}ms")
print(f"  - SynthID: {response.response.metadata.content_authenticity.synth_id}")

Mengkonversi ke Berbagai Format

from PIL import Image
import io
import base64

def image_to_different_formats(image_bytes):
    """Konversi gambar yang dihasilkan ke beberapa format."""
    # Muat sebagai Gambar PIL
    img = Image.open(io.BytesIO(image_bytes))

    # Simpan sebagai PNG
    img.save("image.png", "PNG")

    # Simpan sebagai JPEG (dengan kualitas)
    img.save("image.jpg", "JPEG", quality=95)

    # Konversi ke WebP (ukuran file lebih kecil)
    img.save("image.webp", "WEBP", quality=85)

    # Dapatkan base64 untuk penyematan
    buffered = io.BytesIO()
    img.save(buffered, format="PNG")
    base64_str = base64.b64encode(buffered.getvalue()).decode()

    return base64_str

Penanganan Kesalahan

Penanganan kesalahan yang tepat sangat penting untuk aplikasi produksi:

Penanganan Kesalahan Python

import google.generativeai as genai
from google.api_core.exceptions import (
    ResourceExhausted,
    InvalidArgument,
    ServiceUnavailable
)

genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

def generate_image_with_retry(prompt, max_retries=3):
    """Hasilkan gambar dengan logika percobaan ulang."""

    for attempt in range(max_retries):
        try:
            response = model.generate_images(
                prompt=prompt,
                number_of_images=1
            )
            return response

        except ResourceExhausted as e:
            # Batas kecepatan atau kuota terlampaui
            print(f"Batas kecepatan tercapai (percobaan {attempt + 1}/{max_retries})")
            if attempt < max_retries - 1:
                import time
                time.sleep(2 ** attempt)  # Penundaan eksponensial
            else:
                raise Exception("Batas kecepatan terlampaui. Silakan coba lagi nanti.")

        except InvalidArgument as e:
            # Prompt atau parameter tidak valid
            raise ValueError(f"Permintaan tidak valid: {e}")

        except ServiceUnavailable as e:
            # Layanan sementara tidak tersedia
            print(f"Layanan tidak tersedia (percobaan {attempt + 1}/{max_retries})")
            if attempt < max_retries - 1:
                import time
                time.sleep(5)  # Tunggu 5 detik
            else:
                raise Exception("Layanan tidak tersedia. Silakan coba lagi nanti.")

    return None

# Penggunaan
try:
    result = generate_image_with_retry("Pemandangan indah")
    if result:
        print("Gambar berhasil dihasilkan")
except Exception as e:
    print(f"Error: {e}")

Penanganan Kesalahan JavaScript

const { GoogleGenerativeAI } = require("@google/generative-ai");

const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

async function generateImageWithRetry(prompt, maxRetries = 3) {
  const model = genAI.getGenerativeModel({
    model: "gemini-3.1-flash-image-preview",
  });

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const result = await model.generateImages({
        prompt,
        numberOfImages: 1
      });
      return result;
    } catch (error) {
      console.error(`Percobaan ${attempt + 1} gagal:`, error.message);

      if (error.message.includes("RESOURCE_EXHAUSTED")) {
        // Batas kecepatan tercapai
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Batas kecepatan tercapai. Mencoba ulang dalam ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else if (error.message.includes("INVALID_ARGUMENT")) {
        // Prompt tidak valid
        throw new Error(`Prompt tidak valid: ${error.message}`);
      } else if (attempt === maxRetries - 1) {
        throw error;
      }
    }
  }

  return null;
}

// Penggunaan
generateImageWithRetry("Danau pegunungan yang tenang saat matahari terbit")
  .then(result => {
    if (result) {
      console.log("Gambar berhasil dihasilkan");
    }
  })
  .catch(err => {
    console.error("Gagal menghasilkan gambar:", err.message);
  });

Kode Kesalahan Umum

Pengujian dengan Apidog

Apidog adalah alat yang sangat baik untuk menguji dan men-debug integrasi Nano Banana 2 API Anda:

Menyiapkan Ruang Kerja Apidog Anda

1. Buka Apidog dan buat proyek baru
2. Tambahkan variabel lingkungan:

GEMINI_API_KEY: kunci_api_anda_di_sini
BASE_URL: https://generativelanguage.googleapis.com/v1beta

Membuat Permintaan API

Endpoint: POST /models/gemini-3.1-flash-image-preview:predict

Header:

Authorization: Bearer {{GEMINI_API_KEY}}
Content-Type: application/json

Body Permintaan:

{
  "prompt": "{{prompt}}",
  "number_of_images": 1,
  "aspect_ratio": "1:1"
}

Parameter Kueri:

key: {{GEMINI_API_KEY}}

Menulis Skrip Uji

// Uji: Pembuatan berhasil
pm.test("Pembuatan gambar berhasil", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.predictions).to.have.property('image');
    pm.expect(jsonData.predictions[0].metadata.finishReason).to.eql('SUCCESS');
});

// Uji: Respons berisi metadata
pm.test("Respons memiliki metadata yang diperlukan", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.metadata).to.have.property('modelVersion');
    pm.expect(jsonData.metadata).to.have.property('processingTimeMs');
});

// Uji: Keaslian konten diverifikasi
pm.test("Keaslian konten diaktifkan", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.metadata.contentAuthenticity.synthID).to.eql('enabled');
});

// Uji: Waktu respons dapat diterima
pm.test("Waktu respons di bawah 5 detik", function() {
    pm.expect(pm.response.responseTime).to.be.below(5000);
});

Membuat Koleksi untuk Pengujian Batch

Simpan permintaan ini di Apidog untuk membangun koleksi uji:

1. Pembuatan Dasar - Pembuatan gambar tunggal
2. Pembuatan Batch - Banyak prompt
3. Konsistensi Karakter - Uji seed yang sama
4. Penanganan Kesalahan - Uji prompt tidak valid
5. Uji Kinerja - Beberapa permintaan bersamaan

Praktik Terbaik Produksi

Saat menerapkan Nano Banana 2 dalam produksi:

1. Amankan Kunci API Anda

# Jangan pernah mengkodekan kunci API secara permanen
# Gunakan variabel lingkungan
import os

API_KEY = os.environ.get("GEMINI_API_KEY")

# Atau gunakan manajer rahasia
# AWS Secrets Manager, HashiCorp Vault, dll.

2. Terapkan Cache

import hashlib
import redis

redis_client = redis.Redis(host='localhost', port=6379, db=0)

def generate_image_cached(prompt, seed=None):
    """Hasilkan gambar dengan caching."""
    # Buat kunci cache dari prompt + seed
    cache_key = f"image:{hashlib.md5(f'{prompt}:{seed}'.encode()).hexdigest()}"

    # Periksa cache
    cached = redis_client.get(cache_key)
    if cached:
        return cached

    # Hasilkan gambar baru
    response = model.generate_images(prompt=prompt, seed=seed)
    image_data = response.generated_images[0].image_bytes

    # Cache selama 24 jam
    redis_client.setex(cache_key, 86400, image_data)

    return image_data

3. Pembatasan Kecepatan (Rate Limiting)

from flask import Flask, request, jsonify
from flask_limiter import Limiter

app = Flask(__name__)
limiter = Limiter(app, key_func=lambda: request.headers.get("X-API-Key"))

@app.route("/generate", methods=["POST"])
@limiter.limit("10 per minute")  # Sesuaikan berdasarkan kuota Anda
def generate():
    # Logika pembuatan Anda
    pass

4. Pemantauan dan Pencatatan (Logging)

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def generate_with_logging(prompt):
    logger.info(f"Menghasilkan gambar untuk prompt: {prompt[:50]}...")

    start_time = time.time()
    try:
        response = model.generate_images(prompt=prompt)
        elapsed = time.time() - start_time

        logger.info(f"Berhasil dihasilkan dalam {elapsed:.2f} detik")
        return response

    except Exception as e:
        elapsed = time.time() - start_time
        logger.error(f"Gagal setelah {elapsed:.2f} detik: {e}")
        raise

5. Webhook untuk Pemrosesan Asinkron

Untuk pekerjaan batch besar, gunakan webhook:

# Permintaan dengan webhook
response = model.generate_images(
    prompt="Hasilkan 10 gambar produk",
    number_of_images=10,
    webhook_url="https://your-server.com/webhook/nano-banana"
)

# Penangan webhook Anda
@app.route("/webhook/nano-banana", methods=["POST"])
def handle_webhook():
    data = request.json

    if data["status"] == "completed":
        images = data["images"]
        # Proses gambar yang selesai
    elif data["status"] == "failed":
        # Tangani kegagalan
        pass

    return jsonify({"received": True})

Kesimpulan

Nano Banana 2 API menyediakan cara yang ampuh untuk mengintegrasikan pembuatan gambar AI ke dalam aplikasi Anda. Dengan dukungan untuk berbagai bahasa pemrograman, parameter yang fleksibel, dan penanganan kesalahan yang kuat, Anda dapat membangun segalanya mulai dari generator gambar sederhana hingga alur kerja produksi yang kompleks.

Poin-poin penting:

• Memulai memerlukan proyek Google Cloud dan kunci API
• SDK Python dan JavaScript membuat integrasi menjadi mudah
• Parameter lanjutan seperti seed dan prompt negatif memberi Anda kontrol yang baik
• Apidog membantu menguji dan men-debug integrasi API Anda
• Penerapan produksi memerlukan keamanan, caching, pembatasan kecepatan, dan pemantauan

Mulailah dengan contoh dasar dalam panduan ini, lalu secara bertahap tambahkan fitur lanjutan saat Anda semakin nyaman dengan API.

Langkah Selanjutnya: