Google Nano Banana 2 API: Anleitung zur Nutzung

Die Entwicklung von Anwendungen mit KI-Bildgenerierung fühlt sich wie Magie an – bis man auf die Wand komplexer API-Dokumentationen, Authentifizierungs-Schwierigkeiten und Debugging-Alpträume stößt. Sie haben gesehen, was Nano Banana 2 leisten kann: atemberaubende Bilder, die aus Text-Prompts generiert werden, Pro-Qualität mit Flash-Geschwindigkeit und Funktionen wie Subjektkonsistenz, die Multi-Bild-Workflows ermöglichen. Aber die tatsächliche Integration in Ihre Codebasis? Genau da bleiben die meisten Entwickler stecken.

Sie haben wahrscheinlich versucht, sich durch die Google-Dokumentation zu kämpfen, Authentifizierungsabläufe zusammenzufügen und Anfragen manuell in einer CLI zu testen. Vielleicht haben Sie bereits Ihr API-Kontingent beim Debuggen fehlerhafter Anfragen verbraucht oder sich gefragt, warum Ihre Bilder jedes Mal unscharf zurückkommen. Die Wahrheit ist, dass die Integration jeder neuen API, insbesondere einer so leistungsstarken wie Nano Banana 2, mehr erfordert als nur das Lesen der Dokumentation. Sie benötigen einen Workflow, der es Ihnen ermöglicht, schnell zu testen, Prompts zu iterieren und Ihre API-Aufrufe effizient zu verwalten.

In diesem Leitfaden führen wir Sie durch alles, was Sie benötigen, um Nano Banana 2 in Ihre Anwendungen zu integrieren, von der Einrichtung Ihres Google Cloud-Projekts bis zum Schreiben von produktionsreifen Code in Python und JavaScript. Aber das Besondere an diesem Leitfaden ist: Wir zeigen Ihnen, wie Sie jeden Schritt mit Apidog testen und debuggen können, sodass Sie nicht nur Code kopieren, sondern einen Workflow aufbauen, den Sie pflegen und skalieren können.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

• Ein Google Cloud-Konto (oder registrieren Sie sich unter cloud.google.com)
• Grundlegendes Verständnis von REST-APIs
• Python 3.8+ oder Node.js 18+ installiert
• Einen API-Client wie Apidog zum Testen

Dieser Leitfaden geht davon aus, dass Sie mit HTTP-Anfragen und der Verarbeitung von JSON-Daten vertraut sind. Wenn Sie neu bei APIs sind, schauen Sie sich unseren API-Testleitfaden für die Grundlagen an.

Einrichten Ihres Google Cloud-Projekts

Um die Nano Banana 2 API zu verwenden, benötigen Sie ein Google Cloud-Projekt mit aktivierter Generative Language API.

Schritt 1: Ein neues Projekt erstellen

1. Gehen Sie zur Google Cloud Console
2. Klicken Sie auf "Projekt auswählen" → "Neues Projekt"
3. Geben Sie einen Projektnamen ein (z.B. "nano-banana-image-gen")
4. Klicken Sie auf "Erstellen"
5. Warten Sie, bis das Projekt erstellt wurde

Schritt 2: API-Zugriff konfigurieren

1. Gehen Sie zu "APIs & Dienste" → "Anmeldedaten"
2. Klicken Sie auf "Anmeldedaten erstellen" → "API-Schlüssel"
3. Kopieren Sie Ihren API-Schlüssel (Sie werden ihn später benötigen)

Profi-Tipp:

Ihren API-Schlüssel erhalten

Es gibt zwei Möglichkeiten, API-Zugriff zu erhalten:

Option 1: Google Cloud Console (Empfohlen für die Produktion)

Befolgen Sie die obigen Schritte – der von Ihnen erstellte API-Schlüssel ist Ihr Zugangsdaten.

Option 2: Google AI Studio (Empfohlen für die Entwicklung)

1. Gehen Sie zu Google AI Studio
2. Melden Sie sich mit Ihrem Google-Konto an
3. Klicken Sie in der Navigation auf "API-Schlüssel abrufen"
4. Klicken Sie auf "API-Schlüssel erstellen" (oder wählen Sie ein bestehendes Projekt aus)
5. Kopieren Sie Ihren API-Schlüssel

Der AI Studio-Schlüssel eignet sich hervorragend für Entwicklung und Tests. Für die Produktion verwenden Sie den Google Cloud Console-Schlüssel für eine bessere Verwaltung und Sicherheit.

Ihre erste API-Anfrage

Lassen Sie uns eine einfache Bildgenerierungsanfrage stellen, um zu überprüfen, ob alles funktioniert.

cURL verwenden

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

Die Antwort verstehen

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

Das Feld `data` enthält ein base64-kodiertes PNG-Bild. Sie müssen es dekodieren, um das Bild zu speichern oder anzuzeigen.

Python-Integration

So integrieren Sie Nano Banana 2 in Ihre Python-Anwendungen:

Die Client-Bibliothek installieren

pip install google-generativeai

Grundlegende Bildgenerierung

import google.generativeai as genai
import base64
import os

# Configure the API with your key
genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))

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

# Generate an image
response = model.generate_images(
    prompt="A modern minimalist office with natural lighting, indoor plants, standing desk, 4k quality",
    number_of_images=1
)

# Save the image
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")

Erweiterte Bildgenerierung mit Parametern

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

# Generate with advanced parameters
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"
)

# Process the response
for idx, generated_image in enumerate(response.generated_images):
    # Convert to PIL Image
    image = Image.open(io.BytesIO(generated_image.image_bytes))

    # Save with custom name
    image.save(f"generated_image_{idx}.png")

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

Batch-Bildgenerierung

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

# Generate multiple images at once
prompts = [
    "A red sports car on a mountain road",
    "A cozy coffee shop interior",
    "A minimalist bedroom design",
    "A tropical beach sunset"
]

# Generate all images
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")

Beispiel für Charakterkonsistenz

import google.generativeai as genai

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

# Base character description
base_character = "A friendly cartoon robot with round body, blue eyes, antenna on head, white and light blue color scheme"

# Generate base character (note the seed for consistency)
response1 = model.generate_images(
    prompt=base_character + ", front view, standing pose",
    number_of_images=1,
    seed=42  # Important: note this seed
)

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

# Generate variations using the same seed
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  # Same seed maintains consistency
    )

    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-Integration

Die Client-Bibliothek installieren

npm install @google/generative-ai

Grundlegende Bildgenerierung

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

// Initialize with API key
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

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

  // Generate image
  const result = await model.generateImages({
    prompt: "A beautiful sunset over the ocean with palm trees silhouette",
    numberOfImages: 1,
  });

  // Process the response
  if (result.generatedImages && result.generatedImages.length > 0) {
    const imageData = result.generatedImages[0].imageBytes;

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

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

generateImage().catch(console.error);

Umgang mit Base64-Antworten

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];

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

  // Save with metadata in filename
  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-Beispiel

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

// Image generation endpoint
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
    });

    // Convert images to base64 for response
    const images = result.generatedImages.map((img, idx) => ({
      id: idx,
      seed: img.seed,
      finishReason: img.finishReason,
      data: img.imageBytes // Base64 encoded
    }));

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

// Batch generation endpoint
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");
});

Erweiterte Parameter

Nano Banana 2 unterstützt verschiedene Parameter, um Ihre Bildgenerierung zu optimieren:

Parameterreferenz

Auflösungsoptionen

# Available resolutions
resolutions = [
    "512x512",    # Thumbnail, social media
    "768x768",    # Small web images
    "1024x1024",  # Standard square
    "1024x768",   # 4:3 landscape
    "1280x720",   # HD ready
    "1920x1080",  # Full HD
    "2048x2048",  # High quality
    "3840x2160"   # 4K
]

# Using specific resolution
response = model.generate_images(
    prompt="Professional product photography of a watch",
    resolution="2048x2048"
)

Seitenverhältnisse

aspect_ratios = [
    "1:1",    # Square (Instagram posts)
    "4:3",    # Standard photo
    "16:9",   # Landscape (YouTube, web)
    "9:16",   # Portrait (Stories, TikTok)
    "21:9",   # Ultrawide
    "3:4",    # Portrait standard
    "2:3"     # Portrait photo
]

# Using specific aspect ratio
response = model.generate_images(
    prompt="Modern office interior design",
    aspect_ratio="16:9"
)

Umgang mit Antworten

Parsen der Antwortstruktur

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
)

# Access predictions (generated images)
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)}")

# Access metadata
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}")

Konvertierung in verschiedene Formate

from PIL import Image
import io
import base64

def image_to_different_formats(image_bytes):
    """Convert generated image to multiple formats."""
    # Load as PIL Image
    img = Image.open(io.BytesIO(image_bytes))

    # Save as PNG
    img.save("image.png", "PNG")

    # Save as JPEG (with quality)
    img.save("image.jpg", "JPEG", quality=95)

    # Convert to WebP (smaller file size)
    img.save("image.webp", "WEBP", quality=85)

    # Get base64 for embedding
    buffered = io.BytesIO()
    img.save(buffered, format="PNG")
    base64_str = base64.b64encode(buffered.getvalue()).decode()

    return base64_str

Fehlerbehandlung

Eine ordnungsgemäße Fehlerbehandlung ist für Produktionsanwendungen unerlässlich:

Python-Fehlerbehandlung

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):
    """Generate image with retry logic."""

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

        except ResourceExhausted as e:
            # Rate limit or quota exceeded
            print(f"Rate limited (attempt {attempt + 1}/{max_retries})")
            if attempt < max_retries - 1:
                import time
                time.sleep(2 ** attempt)  # Exponential backoff
            else:
                raise Exception("Rate limit exceeded. Please try again later.")

        except InvalidArgument as e:
            # Invalid prompt or parameters
            raise ValueError(f"Invalid request: {e}")

        except ServiceUnavailable as e:
            # Service temporarily unavailable
            print(f"Service unavailable (attempt {attempt + 1}/{max_retries})")
            if attempt < max_retries - 1:
                import time
                time.sleep(5)  # Wait 5 seconds
            else:
                raise Exception("Service unavailable. Please try again later.")

    return None

# Usage
try:
    result = generate_image_with_retry("A beautiful landscape")
    if result:
        print("Image generated successfully")
except Exception as e:
    print(f"Error: {e}")

JavaScript-Fehlerbehandlung

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(`Attempt ${attempt + 1} failed:`, error.message);

      if (error.message.includes("RESOURCE_EXHAUSTED")) {
        // Rate limited
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Rate limited. Retrying in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else if (error.message.includes("INVALID_ARGUMENT")) {
        // Invalid prompt
        throw new Error(`Invalid prompt: ${error.message}`);
      } else if (attempt === maxRetries - 1) {
        throw error;
      }
    }
  }

  return null;
}

// Usage
generateImageWithRetry("A serene mountain lake at sunrise")
  .then(result => {
    if (result) {
      console.log("Image generated successfully");
    }
  })
  .catch(err => {
    console.error("Failed to generate image:", err.message);
  });

Häufige Fehlercodes

Testen mit Apidog

Apidog ist ein hervorragendes Tool zum Testen und Debuggen Ihrer Nano Banana 2 API-Integration:

Einrichten Ihres Apidog-Arbeitsbereichs

1. Öffnen Sie Apidog und erstellen Sie ein neues Projekt
2. Fügen Sie Umgebungsvariablen hinzu:

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

API-Anfragen erstellen

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

Header:

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

Anfragekörper:

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

Abfrageparameter:

key: {{GEMINI_API_KEY}}

Testskripte schreiben

// Test: Successful generation
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: Response contains metadata
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: Content authenticity verified
pm.test("Content authenticity enabled", function() {
    var jsonData = pm.response.json();
    pm.expect(jsonData.metadata.contentAuthenticity.synthID).to.eql('enabled');
});

// Test: Response time acceptable
pm.test("Response time under 5 seconds", function() {
    pm.expect(pm.response.responseTime).to.be.below(5000);
});

Eine Sammlung für Batch-Tests erstellen

Speichern Sie diese Anfragen in Apidog, um eine Testsammlung zu erstellen:

1. Grundlegende Generierung - Einzelne Bildgenerierung
2. Batch-Generierung - Mehrere Prompts
3. Charakterkonsistenz - Test mit gleichem Seed
4. Fehlerbehandlung - Test mit ungültigem Prompt
5. Leistungstest - Mehrere gleichzeitige Anfragen

Best Practices für die Produktion

Beim Einsatz von Nano Banana 2 in der Produktion:

1. Sichern Sie Ihren API-Schlüssel

# API-Schlüssel niemals fest im Code hinterlegen
# Umgebungsvariablen verwenden
import os

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

# Oder einen Geheimnis-Manager verwenden
# AWS Secrets Manager, HashiCorp Vault usw.

2. Caching implementieren

import hashlib
import redis

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

def generate_image_cached(prompt, seed=None):
    """Bild mit Caching generieren."""
    # Cache-Schlüssel aus Prompt + Seed erstellen
    cache_key = f"image:{hashlib.md5(f'{prompt}:{seed}'.encode()).hexdigest()}"

    # Cache prüfen
    cached = redis_client.get(cache_key)
    if cached:
        return cached

    # Neues Bild generieren
    response = model.generate_images(prompt=prompt, seed=seed)
    image_data = response.generated_images[0].image_bytes

    # Für 24 Stunden cachen
    redis_client.setex(cache_key, 86400, image_data)

    return image_data

3. Ratenbegrenzung

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")  # An Ihr Kontingent anpassen
def generate():
    # Ihre Generierungslogik
    pass

4. Überwachung und Protokollierung

import logging

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

def generate_with_logging(prompt):
    logger.info(f"Bild wird generiert für Prompt: {prompt[:50]}...")

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

        logger.info(f"Erfolgreich generiert in {elapsed:.2f}s")
        return response

    except Exception as e:
        elapsed = time.time() - start_time
        logger.error(f"Fehlgeschlagen nach {elapsed:.2f}s: {e}")
        raise

5. Webhook für asynchrone Verarbeitung

Für große Batch-Jobs verwenden Sie Webhooks:

# Anfrage mit Webhook
response = model.generate_images(
    prompt="Generate 10 product images",
    number_of_images=10,
    webhook_url="https://your-server.com/webhook/nano-banana"
)

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

    if data["status"] == "completed":
        images = data["images"]
        # Abgeschlossene Bilder verarbeiten
    elif data["status"] == "failed":
        # Fehler behandeln
        pass

    return jsonify({"received": True})

Fazit

Die Nano Banana 2 API bietet eine leistungsstarke Möglichkeit, die KI-Bildgenerierung in Ihre Anwendungen zu integrieren. Mit Unterstützung für mehrere Programmiersprachen, flexiblen Parametern und robuster Fehlerbehandlung können Sie alles von einfachen Bildgeneratoren bis hin zu komplexen Produktions-Workflows erstellen.

Wichtigste Erkenntnisse:

• Für den Einstieg sind ein Google Cloud-Projekt und ein API-Schlüssel erforderlich
• Python- und JavaScript-SDKs erleichtern die Integration
• Erweiterte Parameter wie Seeds und negative Prompts ermöglichen eine feine Kontrolle
• Apidog hilft beim Testen und Debuggen Ihrer API-Integration
• Produktionsbereitstellungen erfordern Sicherheit, Caching, Ratenbegrenzung und Überwachung

Beginnen Sie mit den grundlegenden Beispielen in diesem Leitfaden und fügen Sie dann schrittweise erweiterte Funktionen hinzu, sobald Sie mit der API vertrauter sind.

Nächster Schritt: