Google Nano Banana 2 API Nasıl Kullanılır

Yapay zeka görsel üretimiyle uygulama geliştirmek sihir gibi hissettirir; ta ki karmaşık API belgeleri, kimlik doğrulama sorunları ve hata ayıklama kabusları duvarına çarpana kadar. Nano Banana 2'nin neler yapabileceğini gördünüz: metin istemlerinden çarpıcı görseller, Flash hızında Pro kalitesinde çıktılar ve çoklu görsel iş akışlarını mümkün kılan konu tutarlılığı gibi özellikler. Peki ya bunu kod tabanınıza gerçekten entegre etmek? İşte çoğu geliştiricinin takıldığı yer burası.

Muhtemelen Google'ın belgelerini didik didik ettiniz, kimlik doğrulama akışlarını bir araya getirdiniz ve istekleri bir CLI'da manuel olarak test ettiniz. Belki de bozuk istekleri ayıklarken API kotanızı çoktan tükettiniz veya görsellerinizin neden her seferinde bulanık geldiğini merak ettiniz. Gerçek şu ki, herhangi bir yeni API'yi, özellikle de Nano Banana 2 kadar güçlü bir API'yi entegre etmek, sadece belgeleri okumaktan daha fazlasını gerektirir. Hızlı test yapmanıza, istemleri yinelemenize ve API çağrılarınızı verimli bir şekilde yönetmenize olanak tanıyan bir iş akışına ihtiyacınız var.

Bu kılavuzda, Google Cloud projenizi kurmaktan Python ve JavaScript'te üretime hazır kod yazmaya kadar Nano Banana 2'yi uygulamalarınıza entegre etmek için ihtiyacınız olan her şeyi adım adım anlatacağız. Ancak bu kılavuzu farklı kılan şey şu: Her adımı Apidog kullanarak nasıl test edip hata ayıklayacağınızı göstereceğiz, böylece sadece kod kopyalamakla kalmayacak, sürdürebileceğiniz ve ölçeklendirebileceğiniz bir iş akışı oluşturacaksınız.

Ön Koşullar

Başlamadan önce şunlara sahip olduğunuzdan emin olun:

• Bir Google Cloud hesabı (veya cloud.google.com adresinden kaydolun)
• REST API'leri hakkında temel anlayış
• Python 3.8+ veya Node.js 18+ kurulu
• Test için Apidog gibi bir API istemcisi

Bu kılavuz, HTTP istekleri yapmaya ve JSON verilerini işlemeye aşina olduğunuzu varsayar. API'lere yeni başlıyorsanız, temeller için API Test Kılavuzumuzu inceleyin.

Google Cloud Projenizi Kurma

Nano Banana 2 API'sini kullanmak için Generative Language API'sinin etkinleştirildiği bir Google Cloud projesine ihtiyacınız var.

Adım 1: Yeni Bir Proje Oluşturun

1. Google Cloud Konsolu'na gidin
2. "Proje seçin" → "Yeni Proje"ye tıklayın
3. Bir proje adı girin (örneğin, "nano-banana-image-gen")
4. "Oluştur"a tıklayın
5. Projenin oluşturulmasını bekleyin

Adım 2: API Erişimini Yapılandırın

1. "API'ler ve Hizmetler" → "Kimlik Bilgileri"ne gidin
2. "Kimlik Bilgileri Oluştur" → "API Anahtarı"na tıklayın
3. API anahtarınızı kopyalayın (daha sonra ihtiyacınız olacak)

Profesyonel İpucu:

API Anahtarınızı Alma

API erişimi elde etmenin iki yolu vardır:

Seçenek 1: Google Cloud Konsolu (Üretim İçin Önerilir)

Yukarıdaki adımları takip edin; oluşturduğunuz API anahtarı sizin erişim kimlik bilginizdir.

Seçenek 2: Google AI Studio (Geliştirme İçin Önerilir)

1. Google AI Studio'ya gidin
2. Google hesabınızla oturum açın
3. Gezinme çubuğunda "API Anahtarı Al"a tıklayın
4. "API Anahtarı Oluştur"a tıklayın (veya mevcut bir projeyi seçin)
5. API anahtarınızı kopyalayın

AI Studio anahtarı, geliştirme ve test için harikadır. Üretim için, daha iyi yönetim ve güvenlik için Google Cloud Konsolu anahtarını kullanın.

İlk API İsteğiniz

Her şeyin çalıştığını doğrulamak için basit bir görsel oluşturma isteği yapalım.

cURL Kullanarak

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": "A cute banana character wearing sunglasses, fun cartoon style",
    "number_of_images": 1
  }'

Yanıtı Anlama

{
  "predictions": [
    {
      "image": {
        "mimeType": "image/png",
        "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
      },
      "generatedImageId": "img_abc123xyz",
      "metadata": {
        "prompt": "A cute banana character wearing sunglasses, fun cartoon style",
        "seed": 12345,
        "finishReason": "SUCCESS"
      }
    }
  ],
  "metadata": {
    "modelVersion": "gemini-3.1-flash-image-preview",
    "processingTimeMs": 1250,
    "contentAuthenticity": {
      "synthID": "enabled",
      "c2pa": "enabled"
    }
  }
}

data alanı, base64 kodlu bir PNG görseli içerir. Görseli kaydetmek veya görüntülemek için bunu kodunu çözmeniz gerekir.

Python Entegrasyonu

Nano Banana 2'yi Python uygulamalarınıza nasıl entegre edeceğiniz aşağıda açıklanmıştır:

İstemci Kütüphanesini Kurma

pip install google-generativeai

Temel Görsel Oluşturma

import google.generativeai as genai
import base64
import os

# API'yi anahtarınızla yapılandırın
genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))

# Modeli oluşturun
model = genai.GenerativeModel("gemini-3.1-flash-image-preview")

# Bir görsel oluşturun
response = model.generate_images(
    prompt="A modern minimalist office with natural lighting, indoor plants, standing desk, 4k quality",
    number_of_images=1
)

# Görseli kaydedin
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("Image saved to output_image.png")

Parametrelerle Gelişmiş Görsel Oluşturma

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

# Gelişmiş parametrelerle oluşturma
response = model.generate_images(
    prompt="A futuristic cityscape at night with neon lights, flying cars, cyberpunk aesthetic",
    number_of_images=1,
    aspect_ratio="16:9",
    negative_prompt="blurry, low quality, distorted, ugly",
    safety_filter_level="block_medium_and_above"
)

# Yanıtı işleme
for idx, generated_image in enumerate(response.generated_images):
    # PIL Görseline dönüştür
    image = Image.open(io.BytesIO(generated_image.image_bytes))

    # Özel adla kaydet
    image.save(f"generated_image_{idx}.png")

    # Meta verilere eriş
    print(f"Image {idx}: {generated_image.finish_reason}")
    print(f"Seed: {generated_image.seed}")

Toplu Görsel Oluşturma

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

# Bir kerede birden fazla görsel oluştur
prompts = [
    "A red sports car on a mountain road",
    "A cozy coffee shop interior",
    "A minimalist bedroom design",
    "A tropical beach sunset"
]

# Tüm görselleri oluştur
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"Generated: image_{idx + 1}.png")

Karakter Tutarlılığı Örneği

import google.generativeai as genai

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

# Temel karakter açıklaması
base_character = "A friendly cartoon robot with round body, blue eyes, antenna on head, white and light blue color scheme"

# Temel karakteri oluştur (tutarlılık için seed'e dikkat edin)
response1 = model.generate_images(
    prompt=base_character + ", front view, standing pose",
    number_of_images=1,
    seed=42  # Önemli: bu seed'e dikkat edin
)

base_seed = response1.generated_images[0].seed
print(f"Base character seed: {base_seed}")

# Aynı seed'i kullanarak varyasyonlar oluştur
poses = [
    "sitting pose",
    "waving hand",
    "holding a ball",
    "walking"
]

for pose in poses:
    response = model.generate_images(
        prompt=f"{base_character}, {pose}, same character as seed {base_seed}",
        number_of_images=1,
        seed=base_seed  # Aynı seed tutarlılığı korur
    )

    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"Generated: {filename}")

JavaScript/Node.js Entegrasyonu

İstemci Kütüphanesini Kurma

npm install @google/generative-ai

Temel Görsel Oluşturma

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

// API anahtarıyla başlat
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

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

  // Görsel oluştur
  const result = await model.generateImages({
    prompt: "A beautiful sunset over the ocean with palm trees silhouette",
    numberOfImages: 1,
  });

  // Yanıtı işleme
  if (result.generatedImages && result.generatedImages.length > 0) {
    const imageData = result.generatedImages[0].imageBytes;

    // Dosyaya kaydet
    fs.writeFileSync("sunset.png", Buffer.from(imageData, "base64"));
    console.log("Image saved to sunset.png");

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

generateImage().catch(console.error);

Base64 Yanıtlarını İşleme

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: "Professional headshot of a person in business attire, studio lighting",
    numberOfImages: 1,
    aspectRatio: "1:1",
    resolution: "1024x1024"
  });

  const generatedImage = result.generatedImages[0];

  // Base64 kodunu çöz
  const imageBuffer = Buffer.from(generatedImage.imageBytes, "base64");

  // Dosya adına meta veri ekleyerek kaydet
  const filename = `portrait_${generatedImage.seed}.png`;
  fs.writeFileSync(filename, imageBuffer);

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

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

Express.js REST API Örneği

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());

// Görsel oluşturma uç noktası
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
    });

    // Yanıt için görselleri base64'e dönüştür
    const images = result.generatedImages.map((img, idx) => ({
      id: idx,
      seed: img.seed,
      finishReason: img.finishReason,
      data: img.imageBytes // Base64 kodlu
    }));

    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
    });
  }
});

// Toplu oluşturma uç noktası
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 running on port 3000");
});

Gelişmiş Parametreler

Nano Banana 2, görsel üretiminizi hassas bir şekilde ayarlamak için çeşitli parametreleri destekler:

Parametre Referansı

Çözünürlük Seçenekleri

# Mevcut çözünürlükler
resolutions = [
    "512x512",    # Küçük resim, sosyal medya
    "768x768",    # Küçük web görselleri
    "1024x1024",  # Standart kare
    "1024x768",   # 4:3 yatay
    "1280x720",   # HD hazır
    "1920x1080",  # Full HD
    "2048x2048",  # Yüksek kalite
    "3840x2160"   # 4K
]

# Belirli çözünürlük kullanarak
response = model.generate_images(
    prompt="Professional product photography of a watch",
    resolution="2048x2048"
)

En Boy Oranları

aspect_ratios = [
    "1:1",    # Kare (Instagram gönderileri)
    "4:3",    # Standart fotoğraf
    "16:9",   # Yatay (YouTube, web)
    "9:16",   # Portre (Hikayeler, TikTok)
    "21:9",   # Ultra geniş
    "3:4",    # Standart portre
    "2:3"     # Portre fotoğrafı
]

# Belirli en boy oranı kullanarak
response = model.generate_images(
    prompt="Modern office interior design",
    aspect_ratio="16:9"
)

Yanıtları İşleme

Yanıt Yapısını Ayrıştırma

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="A fantasy castle on a mountain",
    number_of_images=2
)

# Tahminlere (oluşturulan görseller) erişim
for idx, image in enumerate(response.generated_images):
    print(f"Image {idx + 1}:")
    print(f"  - Seed: {image.seed}")
    print(f"  - Finish Reason: {image.finish_reason}")
    print(f"  - Image Bytes Length: {len(image.image_bytes)}")

# Meta verilere erişim
print("\nMetadata:")
print(f"  - Model Version: {response.response.metadata.model_version}")
print(f"  - Processing Time: {response.response.metadata.processing_time_ms}ms")
print(f"  - SynthID: {response.response.metadata.content_authenticity.synth_id}")

Farklı Formatlara Dönüştürme

from PIL import Image
import io
import base64

def image_to_different_formats(image_bytes):
    """Oluşturulan görseli birden çok formata dönüştürür."""
    # PIL Görseli olarak yükle
    img = Image.open(io.BytesIO(image_bytes))

    # PNG olarak kaydet
    img.save("image.png", "PNG")

    # JPEG olarak kaydet (kalite ile)
    img.save("image.jpg", "JPEG", quality=95)

    # WebP'ye dönüştür (daha küçük dosya boyutu)
    img.save("image.webp", "WEBP", quality=85)

    # Gömme için base64 al
    buffered = io.BytesIO()
    img.save(buffered, format="PNG")
    base64_str = base64.b64encode(buffered.getvalue()).decode()

    return base64_str

Hata Yönetimi

Üretim uygulamaları için uygun hata yönetimi çok önemlidir:

Python Hata Yönetimi

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):
    """Yeniden deneme mantığıyla görsel oluşturur."""

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

        except ResourceExhausted as e:
            # Oran sınırı veya kota aşıldı
            print(f"Oran sınırlaması (deneme {attempt + 1}/{max_retries})")
            if attempt < max_retries - 1:
                import time
                time.sleep(2 ** attempt)  # Üstel geri çekilme
            else:
                raise Exception("Oran sınırı aşıldı. Lütfen daha sonra tekrar deneyin.")

        except InvalidArgument as e:
            # Geçersiz istem veya parametreler
            raise ValueError(f"Geçersiz istek: {e}")

        except ServiceUnavailable as e:
            # Hizmet geçici olarak kullanılamıyor
            print(f"Hizmet kullanılamıyor (deneme {attempt + 1}/{max_retries})")
            if attempt < max_retries - 1:
                import time
                time.sleep(5)  # 5 saniye bekle
            else:
                raise Exception("Hizmet kullanılamıyor. Lütfen daha sonra tekrar deneyin.")

    return None

# Kullanım
try:
    result = generate_image_with_retry("A beautiful landscape")
    if result:
        print("Görsel başarıyla oluşturuldu")
except Exception as e:
    print(f"Hata: {e}")

JavaScript Hata Yönetimi

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(`Deneme ${attempt + 1} başarısız oldu:`, error.message);

      if (error.message.includes("RESOURCE_EXHAUSTED")) {
        // Oran sınırlaması
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Oran sınırlaması. ${delay}ms içinde yeniden deniyor...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else if (error.message.includes("INVALID_ARGUMENT")) {
        // Geçersiz istem
        throw new Error(`Geçersiz istem: ${error.message}`);
      } else if (attempt === maxRetries - 1) {
        throw error;
      }
    }
  }

  return null;
}

// Kullanım
generateImageWithRetry("A serene mountain lake at sunrise")
  .then(result => {
    if (result) {
      console.log("Görsel başarıyla oluşturuldu");
    }
  })
  .catch(err => {
    console.error("Görsel oluşturulamadı:", err.message);
  });

Yaygın Hata Kodları

Apidog ile Test Etme

Apidog, Nano Banana 2 API entegrasyonunuzu test etmek ve hata ayıklamak için mükemmel bir araçtır:

Apidog Çalışma Alanınızı Kurma

1. Apidog'u açın ve yeni bir proje oluşturun
2. Ortam değişkenleri ekleyin:

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

API İstekleri Oluşturma

Uç Nokta: POST /models/gemini-3.1-flash-image-preview:predict

Başlıklar:

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

İstek Gövdesi:

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

Sorgu Parametreleri:

key: {{GEMINI_API_KEY}}

Test Komut Dosyaları Yazma

// Test: Başarılı oluşturma
pm.test("Image generation successful", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.predictions).to.have.property('image');
    pm.expect(jsonData.predictions[0].metadata.finishReason).to.eql('SUCCESS');
});

// Test: Yanıt meta veri içeriyor
pm.test("Response has required metadata", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.metadata).to.have.property('modelVersion');
    pm.expect(jsonData.metadata).to.have.property('processingTimeMs');
});

// Test: İçerik orijinalliği doğrulandı
pm.test("Content authenticity enabled", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.metadata.contentAuthenticity.synthID).to.eql('enabled');
});

// Test: Yanıt süresi kabul edilebilir
pm.test("Response time under 5 seconds", function() {
    pm.expect(pm.response.responseTime).to.be.below(5000);
});

Toplu Test İçin Koleksiyon Oluşturma

Bu istekleri Apidog'a kaydederek bir test koleksiyonu oluşturun:

1. Temel Oluşturma - Tek görsel oluşturma
2. Toplu Oluşturma - Çoklu istemler
3. Karakter Tutarlılığı - Aynı seed testi
4. Hata Yönetimi - Geçersiz istem testi
5. Performans Testi - Çoklu eşzamanlı istekler

Üretim İçin En İyi Uygulamalar

Nano Banana 2'yi üretimde dağıtırken:

1. API Anahtarınızı Güvenceye Alın

# API anahtarlarını asla doğrudan koda yazmayın
# Ortam değişkenlerini kullanın
import os

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

# Veya bir sır yöneticisi kullanın
# AWS Secrets Manager, HashiCorp Vault, vb.

2. Önbelleğe Alma Uygulayın

import hashlib
import redis

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

def generate_image_cached(prompt, seed=None):
    """Önbelleğe alma ile görsel oluşturur."""
    # İstem + seed'den önbellek anahtarı oluştur
    cache_key = f"image:{hashlib.md5(f'{prompt}:{seed}'.encode()).hexdigest()}"

    # Önbelleği kontrol et
    cached = redis_client.get(cache_key)
    if cached:
        return cached

    # Yeni görsel oluştur
    response = model.generate_images(prompt=prompt, seed=seed)
    image_data = response.generated_images[0].image_bytes

    # 24 saat önbelleğe al
    redis_client.setex(cache_key, 86400, image_data)

    return image_data

3. Oran Sınırlaması

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")  # Kotanıza göre ayarlayın
def generate():
    # Oluşturma mantığınız
    pass

4. İzleme ve Kayıt

import logging

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

def generate_with_logging(prompt):
    logger.info(f"Prompt için görsel oluşturuluyor: {prompt[:50]}...")

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

        logger.info(f"Başarıyla {elapsed:.2f}s içinde oluşturuldu")
        return response

    except Exception as e:
        elapsed = time.time() - start_time
        logger.error(f"{elapsed:.2f}s sonra başarısız oldu: {e}")
        raise

5. Asenkron İşleme İçin Webhook

Büyük toplu işler için webhook'ları kullanın:

# Webhook ile istek
response = model.generate_images(
    prompt="10 ürün görseli oluştur",
    number_of_images=10,
    webhook_url="https://your-server.com/webhook/nano-banana"
)

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

    if data["status"] == "completed":
        images = data["images"]
        # Tamamlanan görselleri işle
    elif data["status"] == "failed":
        # Hatayı ele al
        pass

    return jsonify({"received": True})

Sonuç

Nano Banana 2 API'si, yapay zeka görsel üretimini uygulamalarınıza entegre etmenin güçlü bir yolunu sunar. Birden çok programlama dili desteği, esnek parametreler ve sağlam hata yönetimi ile basit görsel oluşturuculardan karmaşık üretim iş akışlarına kadar her şeyi oluşturabilirsiniz.

Temel çıkarımlar:

• Başlamak için bir Google Cloud projesi ve API anahtarı gerekir
• Python ve JavaScript SDK'ları entegrasyonu kolaylaştırır
• Seed'ler ve negatif istemler gibi gelişmiş parametreler size hassas kontrol sağlar
• Apidog, API entegrasyonunuzu test etmenize ve hata ayıklamanıza yardımcı olur
• Üretim dağıtımları güvenlik, önbelleğe alma, oran sınırlaması ve izleme gerektirir

Bu kılavuzdaki temel örneklerle başlayın, ardından API'ye daha aşina oldukça gelişmiş özellikleri aşamalı olarak ekleyin.

Sonraki Adım: