Comment utiliser l'API Google Nano Banana 2

Créer des applications avec la génération d'images par IA ressemble à de la magie, jusqu'à ce que vous vous heurtiez au mur de la documentation API complexe, des maux de tête liés à l'authentification et des cauchemars de débogage. Vous avez vu ce que Nano Banana 2 peut faire : des images époustouflantes générées à partir de requêtes textuelles, une qualité professionnelle à des vitesses fulgurantes, et des fonctionnalités comme la cohérence du sujet qui rendent possibles les flux de travail multi-images. Mais comment l'intégrer réellement dans votre base de code ? C'est là que la plupart des développeurs restent bloqués.

Vous avez probablement essayé de vous frayer un chemin dans la documentation de Google, d'assembler des flux d'authentification et de tester manuellement des requêtes dans une CLI. Peut-être avez-vous déjà épuisé votre quota d'API en déboguant des requêtes mal formées ou vous êtes-vous demandé pourquoi vos images sont toujours floues. La vérité est qu'intégrer une nouvelle API, surtout une aussi puissante que Nano Banana 2, nécessite plus que la simple lecture de la documentation. Vous avez besoin d'un flux de travail qui vous permette de tester rapidement, d'itérer sur les requêtes et de gérer vos appels API efficacement.

Dans ce guide, nous vous accompagnerons à travers tout ce dont vous avez besoin pour intégrer Nano Banana 2 dans vos applications, de la configuration de votre projet Google Cloud à l'écriture de code prêt pour la production en Python et JavaScript. Mais voici ce qui rend ce guide différent : nous vous montrerons comment tester et déboguer chaque étape à l'aide d'Apidog, afin que vous ne fassiez pas que copier du code, mais que vous construisiez un flux de travail que vous pourrez maintenir et faire évoluer.

Prérequis

Avant de commencer, assurez-vous d'avoir :

• Un compte Google Cloud (ou inscrivez-vous sur cloud.google.com)
• Une compréhension de base des API REST
• Python 3.8+ ou Node.js 18+ installés
• Un client API comme Apidog pour les tests

Ce guide suppose que vous êtes familiarisé avec l'envoi de requêtes HTTP et le traitement des données JSON. Si vous débutez avec les API, consultez notre Guide de test d'API pour les fondamentaux.

Configuration de votre projet Google Cloud

Pour utiliser l'API Nano Banana 2, vous avez besoin d'un projet Google Cloud avec l'API Generative Language activée.

Étape 1 : Créer un nouveau projet

1. Allez dans la Console Google Cloud
2. Cliquez sur "Sélectionner un projet" → "Nouveau projet"
3. Entrez un nom de projet (par exemple, "nano-banana-image-gen")
4. Cliquez sur "Créer"
5. Attendez que le projet soit créé

Étape 2 : Configurer l'accès à l'API

1. Allez dans "API et services" → "Identifiants"
2. Cliquez sur "Créer des identifiants" → "Clé API"
3. Copiez votre clé API (vous en aurez besoin plus tard)

Conseil de pro :

Obtenir votre clé API

Il existe deux façons d'obtenir un accès API :

Option 1 : Console Google Cloud (recommandée pour la production)

Suivez les étapes ci-dessus — la clé API que vous avez créée est votre identifiant d'accès.

Option 2 : Google AI Studio (recommandée pour le développement)

1. Allez sur Google AI Studio
2. Connectez-vous avec votre compte Google
3. Cliquez sur "Obtenir la clé API" dans la navigation
4. Cliquez sur "Créer une clé API" (ou sélectionnez un projet existant)
5. Copiez votre clé API

La clé AI Studio est excellente pour le développement et les tests. Pour la production, utilisez la clé de la Console Google Cloud pour une meilleure gestion et sécurité.

Votre première requête API

Faisons une simple requête de génération d'image pour vérifier que tout fonctionne.

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

Comprendre la réponse

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

Le champ data contient une image PNG encodée en base64. Vous devrez la décoder pour enregistrer ou afficher l'image.

Intégration Python

Voici comment intégrer Nano Banana 2 dans vos applications Python :

Installation de la bibliothèque cliente

pip install google-generativeai

Génération d'images de base

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

Génération d'images avancée avec des paramètres

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

Génération d'images par lots

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

Exemple de cohérence de personnage

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

Intégration JavaScript/Node.js

Installation de la bibliothèque cliente

npm install @google/generative-ai

Génération d'images de base

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

Traitement des réponses 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: "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));

Exemple d'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());

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

Paramètres avancés

Nano Banana 2 prend en charge divers paramètres pour affiner votre génération d'images :

Référence des paramètres

Options de résolution

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

Ratios d'aspect

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

Gestion des réponses

Analyse de la structure de la réponse

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

Conversion vers différents formats

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

Gestion des erreurs

Une gestion appropriée des erreurs est essentielle pour les applications en production :

Gestion des erreurs 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):
    """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}")

Gestion des erreurs 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(`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);
  });

Codes d'erreur courants

Tester avec Apidog

Apidog est un excellent outil pour tester et déboguer votre intégration API Nano Banana 2 :

Configuration de votre espace de travail Apidog

1. Ouvrez Apidog et créez un nouveau projet
2. Ajoutez des variables d'environnement :

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

Création de requêtes API

Point de terminaison : POST /models/gemini-3.1-flash-image-preview:predict

En-têtes :

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

Corps de la requête :

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

Paramètres de requête :

key: {{GEMINI_API_KEY}}

Écriture de scripts de test

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

Création d'une collection pour les tests par lots

Enregistrez ces requêtes dans Apidog pour construire une collection de tests :

1. Génération de base - Génération d'une seule image
2. Génération par lots - Plusieurs requêtes
3. Cohérence des personnages - Test de la même graine
4. Gestion des erreurs - Test de requête invalide
5. Test de performance - Plusieurs requêtes concurrentes

Meilleures pratiques en production

Lors du déploiement de Nano Banana 2 en production :

1. Sécurisez votre clé API

# Never hardcode API keys
# Use environment variables
import os

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

# Or use a secrets manager
# AWS Secrets Manager, HashiCorp Vault, etc.

2. Implémentez la mise en cache

import hashlib
import redis

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

def generate_image_cached(prompt, seed=None):
    """Generate image with caching."""
    # Create cache key from prompt + seed
    cache_key = f"image:{hashlib.md5(f'{prompt}:{seed}'.encode()).hexdigest()}"

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

    # Generate new image
    response = model.generate_images(prompt=prompt, seed=seed)
    image_data = response.generated_images[0].image_bytes

    # Cache for 24 hours
    redis_client.setex(cache_key, 86400, image_data)

    return image_data

3. Limitation du débit

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")  # Adjust based on your quota
def generate():
    # Your generation logic
    pass

4. Surveillance et journalisation

import logging

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

def generate_with_logging(prompt):
    logger.info(f"Generating image for prompt: {prompt[:50]}...")

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

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

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

5. Webhook pour le traitement asynchrone

Pour les gros travaux par lots, utilisez des webhooks :

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

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

    if data["status"] == "completed":
        images = data["images"]
        # Process completed images
    elif data["status"] == "failed":
        # Handle failure
        pass

    return jsonify({"received": True})

Conclusion

L'API Nano Banana 2 offre un moyen puissant d'intégrer la génération d'images par IA dans vos applications. Avec la prise en charge de plusieurs langages de programmation, des paramètres flexibles et une gestion robuste des erreurs, vous pouvez créer de simples générateurs d'images à des flux de travail de production complexes.

Points clés à retenir :

• Démarrer nécessite un projet Google Cloud et une clé API
• Les SDK Python et JavaScript facilitent l'intégration
• Les paramètres avancés comme les graines et les requêtes négatives vous donnent un contrôle précis
• Apidog aide à tester et déboguer votre intégration API
• Les déploiements en production nécessitent sécurité, mise en cache, limitation du débit et surveillance

Commencez avec les exemples de base de ce guide, puis ajoutez progressivement des fonctionnalités avancées à mesure que vous vous familiarisez avec l'API.

Étape suivante :