L’API GPT Image 2.5 è disponibile. Crea e modifica immagini →
PoYoPoYo
tutorials

Come utilizzare Nano Banana 2 API su PoYo: guida completa per gli sviluppatori

Poyo.ai Team
Updated
10 min read
Share:

Come utilizzare Nano Banana 2 API su PoYo

Nano Banana 2 API è il percorso Nano Banana a basso costo su PoYo, separato da Nano Banana Pro. Questa guida illustra l'utilizzo di nano-banana-2 e nano-banana-2-edit, a partire da 5 crediti per generazione, circa $0.025 per l'output 1K.

Iniziare con Nano Banana 2 API

Passaggio 1: configura il tuo account PoYo

Innanzitutto, crea il tuo account PoYo e ottieni le tue credenziali API:

  1. Iscriviti su PoYo.ai
  2. Genera la tua chiave API nel dashboard
  3. Aggiungi crediti al tuo account (Nano Banana 2 costa 5 crediti per generazione)

Passaggio 2: installa le dipendenze richieste

# For Node.js/JavaScript
npm install axios

# For Python
pip install requests

# For cURL (no installation needed)

Generazione di base da testo a immagine

Implementazione JavaScript/Node.js

const axios = require('axios');

const generateImage = async (prompt, size = '1:1') => {
  try {
    const response = await axios.post(
      'https://api.poyo.ai/api/generate/submit',
      {
        model: 'nano-banana-2',
        callback_url: 'https://your-domain.com/callback', // Optional webhook
        input: {
          prompt: prompt,
          size: size // Options: '1:1', '16:9', '9:16', '2:3', '3:2', '3:4', '4:3'
        }
      },
      {
        headers: {
          'Authorization': `Bearer YOUR_API_KEY`,
          'Content-Type': 'application/json'
        }
      }
    );

    console.log('Task ID:', response.data.task_id);
    console.log('Status:', response.data.status);
    console.log('Created:', response.data.created_time);
    return response.data;
  } catch (error) {
    console.error('Error generating image:', error.response?.data || error.message);
  }
};

// Example usage
generateImage('A futuristic city skyline at sunset with flying cars', '16:9');

Implementazione Python

import requests
import json

def generate_image(prompt, api_key, size='1:1'):
    url = "https://api.poyo.ai/api/generate/submit"

    payload = {
        "model": "nano-banana-2",
        "callback_url": "https://your-domain.com/callback",  # Optional webhook
        "input": {
            "prompt": prompt,
            "size": size  # Options: '1:1', '16:9', '9:16', '2:3', '3:2', '3:4', '4:3'
        }
    }

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()

        result = response.json()
        print(f"Task ID: {result['task_id']}")
        print(f"Status: {result['status']}")
        print(f"Created: {result['created_time']}")
        return result

    except requests.exceptions.RequestException as e:
        print(f"Error generating image: {e}")
        return None

# Example usage
api_key = "YOUR_API_KEY"
result = generate_image("A serene mountain landscape with crystal clear lake", api_key, '16:9')

Implementazione cURL

curl -X POST "https://api.poyo.ai/api/generate/submit" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nano-banana-2",
    "callback_url": "https://your-domain.com/callback",
    "input": {
      "prompt": "A professional headshot of a confident business woman in modern office setting",
      "size": "1:1"
    }
  }'

Funzionalità avanzate di Nano Banana 2

1. Consapevolezza del contesto culturale

La comprensione culturale di Nano Banana 2 consente contenuti regionali autentici:

const culturalPrompts = [
  "Tokyo springtime cherry blossom picnic with families in traditional dress",
  "Berlin winter street fashion with authentic German architecture",
  "Mumbai monsoon street food vendor with vibrant local atmosphere"
];

// Generate culturally accurate images
culturalPrompts.forEach(async (prompt) => {
  const result = await generateImage(prompt);
  console.log(`Generated culturally aware image for: ${prompt}`);
});

2. Rendering del testo perfetto

Genera immagini con equazioni matematiche e testo complesso:

def generate_educational_content(equation, api_key):
    prompt = f"A clean whiteboard with the mathematical equation '{equation}' written in clear handwriting, classroom setting"

    payload = {
        "model": "nano-banana-2",
        "prompt": prompt,
        "width": 1024,
        "height": 768,
        "guidance_scale": 8.0,
        "num_inference_steps": 60
    }

    return generate_image_with_payload(payload, api_key)

# Generate educational content with perfect text
result = generate_educational_content("E = mc虏", "YOUR_API_KEY")

3. Rapporti d'aspetto multipli

Nano Banana 2 supporta varie proporzioni per diversi casi d'uso:

const aspectRatios = {
  square: { width: 1024, height: 1024 },      // 1:1 - Social media
  portrait: { width: 768, height: 1024 },     // 3:4 - Mobile screens
  landscape: { width: 1024, height: 768 },    // 4:3 - Desktop
  widescreen: { width: 1792, height: 1024 },  // 16:9 - Video thumbnails
  ultrawide: { width: 2048, height: 896 }     // 21:9 - Banners
};

const generateWithAspectRatio = async (prompt, ratio) => {
  const dimensions = aspectRatios[ratio];

  const response = await axios.post(
    'https://api.poyo.ai/v1/image/generations',
    {
      model: 'nano-banana-2',
      prompt: prompt,
      ...dimensions,
      guidance_scale: 7.5
    },
    {
      headers: {
        'Authorization': `Bearer YOUR_API_KEY`,
        'Content-Type': 'application/json'
      }
    }
  );

  return response.data;
};

Modifica delle immagini con Nano Banana 2

Trasformazione da immagine a immagine

const editImage = async (imageUrls, editPrompt, size = '1:1') => {
  try {
    const response = await axios.post(
      'https://api.poyo.ai/api/generate/submit',
      {
        model: 'nano-banana-2-edit',
        callback_url: 'https://your-domain.com/callback', // Optional
        input: {
          prompt: editPrompt,
          image_urls: imageUrls, // Array of reference image URLs
          size: size
        }
      },
      {
        headers: {
          'Authorization': `Bearer YOUR_API_KEY`,
          'Content-Type': 'application/json'
        }
      }
    );

    return response.data;
  } catch (error) {
    console.error('Error editing image:', error.response?.data || error.message);
  }
};

// Example: Transform day scene to night
const result = await editImage(
  ['https://example.com/day-scene.jpg'],
  'Transform this scene to a beautiful night setting with stars and moon',
  '16:9'
);

Gestione dei risultati con i webhook

Nano Banana 2 API utilizza webhook per la consegna dei risultati. Configura un endpoint webhook per ricevere i risultati:

Configurazione dell'endpoint webhook

// Express.js webhook handler
const express = require('express');
const app = express();

app.use(express.json());

// Webhook endpoint to receive results
app.post('/webhook/callback', (req, res) => {
  const { task_id, status, files } = req.body;

  console.log(`Task ${task_id} status: ${status}`);

  if (status === 'finished' && files && files.length > 0) {
    console.log('Generated image URL:', files[0].file_url);
    // Process the completed image
    processGeneratedImage(task_id, files[0].file_url);
  } else if (status === 'failed') {
    console.error('Generation failed for task:', task_id);
    handleGenerationError(task_id);
  }

  res.status(200).send('OK');
});

const processGeneratedImage = (taskId, imageUrl) => {
  // Your logic to handle the completed image
  console.log(`Processing image from task ${taskId}: ${imageUrl}`);
};

app.listen(3000, () => {
  console.log('Webhook server running on port 3000');
});

Alternativa: controllo manuale dello stato

Se preferisci non utilizzare i webhook, puoi controllare manualmente lo stato dell'attività:

const checkTaskStatus = async (taskId) => {
  try {
    const response = await axios.get(
      `https://api.poyo.ai/api/generate/status/${taskId}`,
      {
        headers: {
          'Authorization': `Bearer YOUR_API_KEY`
        }
      }
    );

    return response.data.data; // Returns the task data
  } catch (error) {
    console.error('Error checking status:', error.message);
    return null;
  }
};

const pollForResult = async (taskId, maxAttempts = 30) => {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const taskData = await checkTaskStatus(taskId);

    if (!taskData) break;

    console.log(`Status: ${taskData.status}, Progress: ${taskData.progress}%`);

    if (taskData.status === 'finished') {
      console.log('Image generated successfully!');
      if (taskData.files && taskData.files.length > 0) {
        console.log('Image URL:', taskData.files[0].file_url);
      }
      return taskData;
    } else if (taskData.status === 'failed') {
      console.error('Generation failed:', taskData.error_message);
      return null;
    }

    // Status is 'not_started' or 'running'
    await new Promise(resolve => setTimeout(resolve, 3000)); // Wait 3 seconds
  }

  console.error('Maximum polling attempts reached');
  return null;
};

// Complete workflow example
const completeGeneration = async (prompt) => {
  // Step 1: Submit generation request
  const generation = await generateImage(prompt);

  if (!generation) return null;

  // Step 2: Poll for results
  const result = await pollForResult(generation.task_id);

  return result;
};

Python Controllo dello stato

import time

def check_task_status(task_id, api_key):
    url = f"https://api.poyo.ai/api/generate/status/{task_id}"

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()

        return response.json()['data']
    except requests.exceptions.RequestException as e:
        print(f"Error checking status: {e}")
        return None

def wait_for_completion(task_id, api_key, max_attempts=30):
    for attempt in range(max_attempts):
        task_data = check_task_status(task_id, api_key)

        if not task_data:
            break

        print(f"Status: {task_data['status']}, Progress: {task_data.get('progress', 0)}%")

        if task_data['status'] == 'finished':
            print("Image generated successfully!")
            if task_data.get('files') and len(task_data['files']) > 0:
                print(f"Image URL: {task_data['files'][0]['file_url']}")
            return task_data
        elif task_data['status'] == 'failed':
            print(f"Generation failed: {task_data.get('error_message', 'Unknown error')}")
            return None

        time.sleep(3)  # Wait 3 seconds

    print("Maximum attempts reached")
    return None

# Complete workflow
def complete_image_generation(prompt, api_key, size='1:1'):
    # Step 1: Submit request
    task_result = generate_image(prompt, api_key, size)

    if not task_result:
        return None

    # Step 2: Wait for completion
    final_result = wait_for_completion(task_result['task_id'], api_key)

    return final_result

Gestione degli errori e best practice

Gestione completa degli errori

const robustImageGeneration = async (prompt, size = '1:1', retries = 3) => {
  for (let attempt = 0; attempt < retries; attempt++) {
    try {
      const response = await axios.post(
        'https://api.poyo.ai/api/generate/submit',
        {
          model: 'nano-banana-2',
          input: {
            prompt: prompt,
            size: size
          }
        },
        {
          headers: {
            'Authorization': `Bearer YOUR_API_KEY`,
            'Content-Type': 'application/json'
          },
          timeout: 30000 // 30 second timeout
        }
      );

      return response.data;

    } catch (error) {
      if (error.response) {
        // Server responded with error status
        const status = error.response.status;
        const message = error.response.data?.error || 'Unknown error';

        console.error(`API Error (${status}): ${message}`);

        // Don't retry for certain errors
        if (status === 401 || status === 403) {
          throw new Error('Authentication failed. Check your API key.');
        }

        if (status === 400) {
          throw new Error(`Bad request: ${message}`);
        }

      } else if (error.request) {
        console.error('Network error:', error.message);
      } else {
        console.error('Request setup error:', error.message);
      }

      // If this was the last attempt, throw the error
      if (attempt === retries - 1) {
        throw error;
      }

      // Wait before retrying (exponential backoff)
      const delay = Math.pow(2, attempt) * 1000;
      console.log(`Retrying in ${delay}ms... (Attempt ${attempt + 1}/${retries})`);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
};

Migliori pratiche per la produzione

  1. Limitazione della velocità: implementa una limitazione della velocità adeguata per evitare di raggiungere i limiti API
  2. Caching: memorizza nella cache le generazioni di successo per ridurre le chiamate API
  3. Esperienza utente: mostra indicatori di progresso per generazioni di lunga durata
  4. Recupero errori: implementa strategie di fallback efficaci per le generazioni fallite
class NanoBanana2Client {
  constructor(apiKey, options = {}) {
    this.apiKey = apiKey;
    this.baseURL = 'https://api.poyo.ai/v1';
    this.requestsPerMinute = options.requestsPerMinute || 60;
    this.queue = [];
  }

  async generateImage(prompt, options = {}) {
    const payload = {
      model: 'nano-banana-2',
      prompt,
      width: options.width || 1024,
      height: options.height || 1024,
      guidance_scale: options.guidanceScale || 7.5,
      num_inference_steps: options.steps || 50
    };

    return this.makeRequest('/image/generations', payload);
  }

  async editImage(imageUrl, editPrompt, options = {}) {
    const payload = {
      model: 'nano-banana-2-edit',
      image: imageUrl,
      prompt: editPrompt,
      strength: options.strength || 0.8,
      guidance_scale: options.guidanceScale || 7.5
    };

    return this.makeRequest('/image/edits', payload);
  }

  async makeRequest(endpoint, payload) {
    // Implement rate limiting, error handling, and retries
    // This is a simplified version

    try {
      const response = await axios.post(
        `${this.baseURL}${endpoint}`,
        payload,
        {
          headers: {
            'Authorization': `Bearer ${this.apiKey}`,
            'Content-Type': 'application/json'
          }
        }
      );

      return response.data;
    } catch (error) {
      throw this.handleError(error);
    }
  }

  handleError(error) {
    // Implement comprehensive error handling
    return new Error(`Nano Banana 2 API Error: ${error.message}`);
  }
}

Prompt per l'ottimizzazione delle prestazioni

1. Ingegneria dei prompt

  • Sii specifico: istruzioni dettagliate producono risultati migliori
  • Includi direttive di stile: "fotorealistico", "risoluzione 4K", "professionale"
  • Utilizza il contesto culturale: sfrutta la consapevolezza culturale di Nano Banana 2

2. Regolazione dei parametri

  • guidance_scale: 7.0-8.5 per la maggior parte dei casi d'uso
  • num_inference_steps: 30-60 (più alto per una migliore qualità)
  • strength: 0.6-0.9 per l'editing delle immagini (il valore inferiore preserva più l'originale)

3. Elaborazione batch

const generateBatch = async (prompts) => {
  const generations = await Promise.all(
    prompts.map(prompt => generateImage(prompt))
  );

  const results = await Promise.all(
    generations.map(gen => pollForResult(gen.id))
  );

  return results.filter(result => result !== null);
};

Conclusione

Nano Banana 2 API su PoYo offre funzionalità senza precedenti per la generazione di immagini AI con il suo rivoluzionario flusso di lavoro in 5 fasi, consapevolezza del contesto culturale e rendering perfetto del testo. Seguendo questa guida, puoi integrare queste potenti funzionalità nelle tue applicazioni e creare contenuti visivi di livello professionale.

Per funzionalità più avanzate e la documentazione API completa, visita la documentazione ufficiale Nano Banana 2 API.

Pronto per iniziare a costruire? Ottieni la tua chiave API e inizia a creare con Nano Banana 2 oggi stesso.

Hai bisogno di aiuto con l'implementazione? Unisciti alla nostra comunità di sviluppatori o dai un'occhiata ad altri tutorial API per tecniche avanzate.

Share: