4 diferencias principales entre las llamadas síncronas y asíncronas de Nano Banana Pro API

Al llamar a la Nano Banana Pro API para generar imágenes, ¿cuáles son las diferencias entre una llamada síncrona y una asíncrona? Actualmente, tanto APIYI como la API oficial de Gemini solo admiten el modo de llamada síncrona, pero APIYI ha mejorado significativamente la experiencia del usuario al ofrecer la salida de imágenes mediante URLs de OSS. En este artículo, analizaremos sistemáticamente las diferencias principales entre ambos tipos de llamadas y las soluciones de optimización de APIYI para el formato de salida.

Valor principal: Al finalizar este artículo, comprenderás la diferencia esencial entre las llamadas síncronas y asíncronas en el diseño de APIs, las ventajas de la salida URL de OSS de APIYI frente a la codificación base64, y cómo elegir el mejor método de obtención de imágenes según tus necesidades de negocio.

Comparativa principal de los modos de llamada de Nano Banana Pro API

Cómo funciona la llamada síncrona

La Llamada Síncrona (Synchronous Call) sigue el modelo de petición-espera-respuesta:

1. El cliente inicia la solicitud: Envía la solicitud de generación de imagen al servidor.
2. Mantenimiento de la conexión HTTP: El cliente mantiene abierta la conexión TCP esperando que el servidor termine la inferencia.
3. Espera bloqueante: Durante los 30-170 segundos que dura la inferencia, el cliente no puede realizar otras operaciones en ese hilo.
4. Recepción de la respuesta completa: El servidor devuelve los datos de la imagen generada (base64 o URL).
5. Cierre de la conexión: Se cierra la conexión HTTP una vez finalizado el proceso.

Característica clave: La llamada síncrona es bloqueante (Blocking); el cliente debe esperar la respuesta del servidor antes de continuar. Esto requiere configurar un tiempo de espera (timeout) suficientemente largo (se recomiendan 300s para 1K/2K y 600s para 4K) para evitar que la conexión se interrumpa antes de que termine la inferencia.

Cómo funciona la llamada asíncrona

La Llamada Asíncrona (Asynchronous Call) sigue el modelo de petición-aceptación-notificación:

1. El cliente envía la tarea: Envía la solicitud de generación al servidor.
2. Retorno inmediato del ID de tarea: El servidor acepta la solicitud, devuelve un ID (como task_abc123) y cierra la conexión de inmediato.
3. Inferencia en segundo plano: El servidor genera la imagen en segundo plano mientras el cliente puede realizar otras tareas.
4. Obtención del resultado: El cliente obtiene el resultado mediante uno de estos dos métodos:
   • Sondeo (Polling): Solicita periódicamente el estado en /tasks/task_abc123/status.
   • Webhook: El servidor llama a una URL proporcionada por el cliente cuando la tarea termina.
5. Descarga de la imagen: Una vez completada, se descarga la imagen a través de la URL devuelta.

Característica clave: La llamada asíncrona es no bloqueante (Non-blocking); el cliente puede procesar otras solicitudes justo después de enviar la tarea sin mantener la conexión abierta. Es ideal para procesamientos masivos o tareas donde la inmediatez no es crítica.

💡 Sugerencia técnica: Actualmente, la plataforma APIYI solo admite el modo síncrono, pero gracias a la optimización del tiempo de espera y la salida vía URL de OSS, la experiencia de usuario es excelente. Para generar imágenes por lotes, te recomendamos usar la plataforma APIYI (apiyi.com), que ofrece interfaces estables, tiempos de espera preconfigurados y soporte para alta concurrencia en llamadas síncronas.

Diferencia clave 1: Tiempo de mantenimiento de la conexión y configuración de tiempo de espera (timeout)

Requisitos de mantenimiento de conexión en llamadas sincrónicas

Las llamadas sincrónicas requieren que el cliente mantenga abierta la conexión HTTP durante todo el proceso de generación de la imagen, lo que plantea los siguientes desafíos técnicos:

Ejemplo de llamada sincrónica en Python:

import requests
import time

def generate_image_sync(prompt: str, size: str = "4096x4096") -> dict:
    """
    Llamada sincrónica a la API de Nano Banana Pro para generar imágenes

    Args:
        prompt: Indicación de la imagen (prompt)
        size: Tamaño de la imagen

    Returns:
        Resultado de la respuesta de la API
    """
    start_time = time.time()

    # Llamada sincrónica: mantiene la conexión hasta que se completa la generación
    response = requests.post(
        "http://api.apiyi.com:16888/v1/images/generations",
        json={
            "prompt": prompt,
            "size": size,
            "model": "nano-banana-pro",
            "n": 1,
            "response_format": "url"  # APIYI admite salida por URL
        },
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        timeout=(10, 600)  # Timeout de conexión 10s, timeout de lectura 600s
    )

    elapsed = time.time() - start_time
    print(f"⏱️ Tiempo de llamada sincrónica: {elapsed:.2f} segundos")
    print(f"🔗 Estado de la conexión: mantenida abierta {elapsed:.2f} segundos")

    return response.json()


# Ejemplo de uso
result = generate_image_sync(
    prompt="A futuristic cityscape at sunset",
    size="4096x4096"
)

print(f"✅ URL de la imagen: {result['data'][0]['url']}")

Observaciones clave:

• El cliente se bloquea completamente durante el tiempo de inferencia (100-170 segundos).
• La conexión HTTP permanece abierta, consumiendo recursos del sistema.
• Si el tiempo de espera se configura incorrectamente (por ejemplo, 60 segundos), se desconectará antes de finalizar la inferencia.

Ventajas de las conexiones cortas en llamadas asincrónicas

Las llamadas asincrónicas solo establecen conexiones cortas al enviar la tarea y consultar el estado, lo que reduce drásticamente el tiempo de mantenimiento de la conexión:

Ejemplo de llamada asincrónica en Python (simulación de soporte futuro de APIYI):

import requests
import time

def generate_image_async(prompt: str, size: str = "4096x4096") -> str:
    """
    Llamada asincrónica a la API de Nano Banana Pro para generar imágenes (función futura)

    Args:
        prompt: Indicación de la imagen (prompt)
        size: Tamaño de la imagen

    Returns:
        ID de la tarea
    """
    # Paso 1: Enviar tarea (conexión corta)
    response = requests.post(
        "http://api.apiyi.com:16888/v1/images/generations/async",  # Interfaz futura
        json={
            "prompt": prompt,
            "size": size,
            "model": "nano-banana-pro",
            "n": 1,
            "response_format": "url"
        },
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        timeout=(10, 30)  # El envío de la tarea solo requiere 30s de timeout
    )

    task_data = response.json()
    task_id = task_data["task_id"]
    print(f"✅ Tarea enviada: {task_id}")
    print(f"🔓 Conexión cerrada, se pueden procesar otras tareas")

    return task_id


def poll_task_status(task_id: str, max_wait: int = 300) -> dict:
    """
    Consulta el estado de la tarea hasta que se complete

    Args:
        task_id: ID de la tarea
        max_wait: Tiempo máximo de espera (segundos)

    Returns:
        Resultado generado
    """
    start_time = time.time()
    poll_interval = 5  # Consultar cada 5 segundos

    while time.time() - start_time < max_wait:
        # Consultar estado de la tarea (conexión corta)
        response = requests.get(
            f"http://api.apiyi.com:16888/v1/tasks/{task_id}",  # Interfaz futura
            headers={"Authorization": "Bearer YOUR_API_KEY"},
            timeout=(10, 10)  # La consulta solo requiere 10s de timeout
        )

        status_data = response.json()
        status = status_data["status"]

        if status == "completed":
            elapsed = time.time() - start_time
            print(f"✅ ¡Tarea completada! Tiempo total: {elapsed:.2f} segundos")
            return status_data["result"]

        elif status == "failed":
            raise Exception(f"Tarea fallida: {status_data.get('error')}")

        else:
            print(f"⏳ Estado de la tarea: {status}, esperando {poll_interval} segundos para reintentar...")
            time.sleep(poll_interval)

    raise TimeoutError(f"Tiempo de espera de la tarea agotado: {task_id}")


# Ejemplo de uso
task_id = generate_image_async(
    prompt="A serene mountain landscape",
    size="4096x4096"
)

# Durante la consulta, se pueden procesar otras tareas
print("🚀 Se pueden procesar otras solicitudes de forma concurrente...")

# Consultar estado de la tarea
result = poll_task_status(task_id, max_wait=600)
print(f"✅ URL de la imagen: {result['data'][0]['url']}")

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

# Diccionario global para almacenar resultados de tareas
task_results = {}


@app.route('/webhook/image_completed', methods=['POST'])
def handle_webhook():
    """Recibe el callback Webhook de finalización de tarea asincrónica de APIYI"""
    data = request.json

    task_id = data['task_id']
    status = data['status']
    result = data.get('result')

    if status == 'completed':
        task_results[task_id] = result
        print(f"✅ Tarea {task_id} completada: {result['data'][0]['url']}")
    else:
        print(f"❌ Tarea {task_id} fallida: {data.get('error')}")

    return jsonify({"received": True}), 200


def generate_image_with_webhook(prompt: str, size: str = "4096x4096") -> str:
    """
    Generar imagen asincrónicamente usando el modo Webhook

    Args:
        prompt: Indicación de la imagen (prompt)
        size: Tamaño de la imagen

    Returns:
        ID de la tarea
    """
    response = requests.post(
        "http://api.apiyi.com:16888/v1/images/generations/async",
        json={
            "prompt": prompt,
            "size": size,
            "model": "nano-banana-pro",
            "n": 1,
            "response_format": "url",
            "webhook_url": "https://your-domain.com/webhook/image_completed"  # URL de callback
        },
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        timeout=(10, 30)
    )

    task_id = response.json()["task_id"]
    print(f"✅ Tarea enviada: {task_id}")
    print(f"📞 El Webhook enviará el callback a: https://your-domain.com/webhook/image_completed")

    return task_id


# Iniciar servidor Flask para escuchar el Webhook
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

🎯 Limitaciones actuales: Tanto APIYI como el Gemini oficial actualmente solo admiten el modo de llamada sincrónica; la funcionalidad de llamada asincrónica está planificada para futuras versiones. Para escenarios que requieren generación de imágenes de alta concurrencia, se recomienda utilizar llamadas concurrentes multihilo o multiproceso a la interfaz sincrónica a través de la plataforma APIYI (apiyi.com), configurando tiempos de espera razonables.

Diferencia clave 2: Capacidad de procesamiento concurrente y consumo de recursos

Límites de concurrencia en llamadas sincrónicas

Las llamadas sincrónicas enfrentan problemas significativos de ocupación de recursos en escenarios de alta concurrencia:

Problema de bloqueo de un solo hilo:

import time

# ❌ Incorrecto: Llamada secuencial de un solo hilo, tiempo total = tiempo individual × número de tareas
def generate_multiple_images_sequential(prompts: list) -> list:
    results = []
    start_time = time.time()

    for prompt in prompts:
        result = generate_image_sync(prompt, size="4096x4096")
        results.append(result)

    elapsed = time.time() - start_time
    print(f"❌ La llamada secuencial de {len(prompts)} imágenes tomó: {elapsed:.2f} segundos")
    # Asumiendo 120s por imagen, 10 imágenes = 1200s (¡20 minutos!)

    return results

Optimización de concurrencia multihilo:

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

# ✅ Correcto: Llamada concurrente multihilo, aprovechando al máximo el tiempo de espera de E/S
def generate_multiple_images_concurrent(prompts: list, max_workers: int = 5) -> list:
    """
    Generación concurrente multihilo de múltiples imágenes

    Args:
        prompts: Lista de indicaciones
        max_workers: Número máximo de hilos concurrentes

    Returns:
        Lista de resultados generados
    """
    results = []
    start_time = time.time()

    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # Enviar todas las tareas
        future_to_prompt = {
            executor.submit(generate_image_sync, prompt, "4096x4096"): prompt
            for prompt in prompts
        }

        # Esperar a que se completen todas las tareas
        for future in as_completed(future_to_prompt):
            prompt = future_to_prompt[future]
            try:
                result = future.result()
                results.append(result)
                print(f"✅ Completado: {prompt[:30]}...")
            except Exception as e:
                print(f"❌ Fallido: {prompt[:30]}... - {e}")

    elapsed = time.time() - start_time
    print(f"✅ La llamada concurrente de {len(prompts)} imágenes tomó: {elapsed:.2f} segundos")
    # Asumiendo 120s por imagen, 10 imágenes ≈ 120-150s (2-2.5 minutos)

    return results


# Ejemplo de uso
prompts = [
    "A cyberpunk city at night",
    "A serene forest landscape",
    "An abstract geometric pattern",
    "A futuristic space station",
    "A vintage car in the desert",
    # ...más indicaciones
]

results = generate_multiple_images_concurrent(prompts, max_workers=5)
print(f"🎉 Se generaron {len(results)} imágenes")

Ventajas de concurrencia de las llamadas asincrónicas

Las llamadas asincrónicas tienen una ventaja significativa en escenarios de procesamiento por lotes:

Envío por lotes + Consulta por lotes:

def generate_batch_async(prompts: list) -> list:
    """
    Generación asincrónica por lotes de imágenes (función futura)

    Args:
        prompts: Lista de indicaciones

    Returns:
        Lista de IDs de tareas
    """
    task_ids = []

    # Paso 1: Envío rápido por lotes de todas las tareas (1-3s cada una)
    for prompt in prompts:
        task_id = generate_image_async(prompt, size="4096x4096")
        task_ids.append(task_id)

    print(f"✅ Envío por lotes de {len(task_ids)} tareas completado en aprox. {len(prompts) * 2} segundos")

    # Paso 2: Consulta por lotes del estado de las tareas
    results = []
    for task_id in task_ids:
        result = poll_task_status(task_id, max_wait=600)
        results.append(result)

    return results

Comparativa de rendimiento en procesamiento por lotes (10 imágenes 4K) Escenario: Generación por lotes de 10 imágenes 4096×4096 (aprox. 120 s cada una)

Llamada sincrónica (5 hilos concurrentes)

Llamada asincrónica (futuro)

Métrica de rendimiento Llamada sincrónica (5 hilos) Llamada asincrónica

⏱️ Tiempo total

250 s (4 minutos)

125 s 2x más rápido ✅

🔗 Pico de conexiones

5 conexiones largas

1 conexión corta Ahorro del 80% ✅

⏳ Duración por conexión

120-150 s

3s 40x más rápido ✅

🚫 Bloqueo del cliente

❌ Hilos bloqueados 250 s

✅ Totalmente no bloqueante

🔄 Procesar otras tareas

⚠️ Hilos ocupados

✅ Totalmente posible

Escenario: Lotes pequeños/medianos (10-50 imágenes) • Tiempo real

Escenario: Lotes masivos (100+ imágenes) • Tareas en segundo plano • Soporte futuro

💰 Optimización de costos: Google Gemini API ofrece un modo Batch API que admite procesamiento asincrónico y proporciona un descuento del 50% en el precio (precio estándar $0.133-$0.24/imagen, Batch API $0.067-$0.12/imagen), aunque requiere tolerar un tiempo de entrega de hasta 24 horas. Para escenarios que no requieren generación en tiempo real, considere usar Batch API para reducir costos.

Diferencia clave 3: Ventajas de la salida por URL de OSS en la plataforma APIYI

Comparativa: codificación base64 vs. salida por URL

La API de Nano Banana Pro admite dos formatos de salida para las imágenes:

Problemas de rendimiento de la codificación base64:

1. Inflación del cuerpo de la respuesta en un 33%: La codificación base64 aumenta el volumen de datos en aproximadamente un 33%.

   • Imagen 4K original: aprox. 6 MB
   • Después de codificar en base64: aprox. 8 MB

2. Imposibilidad de aprovechar el CDN: Al estar incrustada en una respuesta JSON, la cadena base64 no puede ser almacenada en caché por un CDN.

3. Presión sobre la memoria en móviles: Decodificar una cadena base64 requiere recursos adicionales de memoria y CPU.

Ventajas de la salida por URL de OSS de APIYI:

import requests

# ✅ 推荐: 使用 APIYI OSS URL 输出
response = requests.post(
    "http://api.apiyi.com:16888/v1/images/generations",
    json={
        "prompt": "A beautiful sunset over mountains",
        "size": "4096x4096",
        "model": "nano-banana-pro",
        "n": 1,
        "response_format": "url"  # 指定 URL 输出
    },
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    timeout=(10, 600)
)

result = response.json()

# 响应体仅包含 URL,大小约 200 字节
print(f"响应体大小: {len(response.content)} 字节")
# 输出: 响应体大小: 234 字节

# OSS URL 示例
image_url = result['data'][0]['url']
print(f"图像 URL: {image_url}")
# 输出: https://apiyi-oss.oss-cn-beijing.aliyuncs.com/nano-banana/abc123.png

# 后续通过标准 HTTP 下载图像,享受 CDN 加速
image_response = requests.get(image_url)
with open("output.png", "wb") as f:
    f.write(image_response.content)

Comparativa: Problemas de rendimiento con salida base64:

# ❌ 不推荐: base64 编码输出
response = requests.post(
    "https://api.example.com/v1/images/generations",
    json={
        "prompt": "A beautiful sunset over mountains",
        "size": "4096x4096",
        "model": "nano-banana-pro",
        "n": 1,
        "response_format": "b64_json"  # base64 编码
    },
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    timeout=(10, 600)
)

result = response.json()

# 响应体包含完整 base64 字符串,大小约 8 MB
print(f"响应体大小: {len(response.content)} 字节")
# 输出: 响应体大小: 8388608 字节 (8 MB!)

# 需要解码 base64 字符串
import base64
image_b64 = result['data'][0]['b64_json']
image_bytes = base64.b64decode(image_b64)

with open("output.png", "wb") as f:
    f.write(image_bytes)

🚀 Configuración recomendada: Al llamar a la API de Nano Banana Pro en la plataforma APIYI, utiliza siempre response_format: "url" para obtener la salida por URL de OSS en lugar de base64. Esto no solo reduce drásticamente el tamaño de la respuesta y el tiempo de transferencia, sino que también permite aprovechar el CDN y la caché del navegador para mejorar la experiencia del usuario.

Diferencia clave 4: Escenarios de aplicación y planes a futuro

Escenarios ideales para llamadas síncronas

Escenarios recomendados:

1. Generación de imágenes en tiempo real: Mostrar la imagen generada inmediatamente después de que el usuario envíe la indicación.
2. Procesamiento por lotes pequeños: Generar de 1 a 10 imágenes; las llamadas concurrentes son suficientes para cumplir con el rendimiento.
3. Integración sencilla: No es necesario implementar sondeo (polling) o Webhooks, lo que reduce la complejidad del desarrollo.
4. Aplicaciones interactivas: Herramientas de dibujo por IA, editores de imágenes y otros escenarios que requieren feedback instantáneo.

Patrón de código típico:

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/generate', methods=['POST'])
def generate_image():
    """实时图像生成接口"""
    data = request.json
    prompt = data['prompt']
    size = data.get('size', '1024x1024')

    # 同步调用,用户等待生成完成
    response = requests.post(
        "http://api.apiyi.com:16888/v1/images/generations",
        json={
            "prompt": prompt,
            "size": size,
            "model": "nano-banana-pro",
            "n": 1,
            "response_format": "url"
        },
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        timeout=(10, 300 if size != '4096x4096' else 600)
    )

    result = response.json()
    return jsonify({
        "success": True,
        "image_url": result['data'][0]['url']
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000)

Escenarios futuros para llamadas asíncronas

Escenarios aplicables (soporte futuro):

1. Generación masiva de imágenes: Generar más de 100 imágenes, como catálogos de productos para e-commerce o bibliotecas de recursos de diseño.
2. Tareas programadas: Generar automáticamente ciertos tipos de imágenes diariamente sin necesidad de respuesta en tiempo real.
3. Procesamiento de bajo costo: Utilizar la API Google Batch para obtener un 50% de descuento, aceptando un tiempo de entrega de hasta 24 horas.
4. Alta concurrencia: Evitar el agotamiento del pool de conexiones cuando cientos de usuarios envían solicitudes simultáneamente.

Patrón de código típico (Futuro):

from flask import Flask, request, jsonify
from celery import Celery
import requests

app = Flask(__name__)
celery = Celery('tasks', broker='redis://localhost:6379/0')

@celery.task
def generate_image_task(prompt: str, size: str, user_id: str):
    """Celery 异步任务:生成图像"""
    # 提交异步任务到 APIYI
    response = requests.post(
        "http://api.apiyi.com:16888/v1/images/generations/async",  # 未来接口
        json={
            "prompt": prompt,
            "size": size,
            "model": "nano-banana-pro",
            "n": 1,
            "response_format": "url",
            "webhook_url": f"https://your-domain.com/webhook/{user_id}"
        },
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        timeout=(10, 30)
    )

    task_id = response.json()["task_id"]
    return task_id


@app.route('/generate_async', methods=['POST'])
def generate_image_async():
    """异步图像生成接口"""
    data = request.json
    prompt = data['prompt']
    size = data.get('size', '1024x1024')
    user_id = data['user_id']

    # 提交 Celery 任务,立即返回
    task = generate_image_task.delay(prompt, size, user_id)

    return jsonify({
        "success": True,
        "message": "任务已提交,完成后将通过 Webhook 通知",
        "task_id": task.id
    })


@app.route('/webhook/<user_id>', methods=['POST'])
def handle_webhook(user_id: str):
    """接收 APIYI 异步任务完成的 Webhook 回调"""
    data = request.json
    task_id = data['task_id']
    result = data['result']

    # 通知用户图像生成完成 (如发送邮件、推送通知等)
    notify_user(user_id, result['data'][0]['url'])

    return jsonify({"received": True}), 200

Hoja de ruta de la plataforma APIYI

💡 Sugerencia para desarrolladores: APIYI planea lanzar funciones de llamada asíncrona en el tercer trimestre de 2026, con soporte para envío de tareas, consulta de estado y notificaciones Webhook. Para desarrolladores con necesidades actuales de procesamiento por lotes, se recomienda utilizar concurrencia multihilo con la interfaz síncrona y obtener acceso a través de la plataforma APIYI (apiyi.com) para disfrutar de puertos HTTP estables y configuraciones de timeout optimizadas.

Preguntas Frecuentes

import requests

# 生成图像并获取 URL
result = generate_image_sync(prompt="A beautiful landscape", size="4096x4096")
temp_url = result['data'][0]['url']
print(f"临时 URL: {temp_url}")

# 下载图像到本地或自己的 OSS
image_response = requests.get(temp_url)
with open("permanent_image.png", "wb") as f:
    f.write(image_response.content)

# 或上传到自己的 OSS (以阿里云 OSS 为例)
import oss2
auth = oss2.Auth('YOUR_ACCESS_KEY', 'YOUR_SECRET_KEY')
bucket = oss2.Bucket(auth, 'oss-cn-beijing.aliyuncs.com', 'your-bucket')
bucket.put_object('images/permanent_image.png', image_response.content)

// 前端代码 (React 示例)
async function generateImage(prompt, size) {
  // 调用自己的后端接口
  const response = await fetch('https://your-backend.com/api/generate', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer YOUR_USER_TOKEN'  // 用户认证 token
    },
    body: JSON.stringify({ prompt, size })
  });

  const result = await response.json();
  return result.image_url;  // 返回 APIYI OSS URL
}

// 使用
const imageUrl = await generateImage("A futuristic city", "4096x4096");
document.getElementById('result-image').src = imageUrl;

# 后端代码 (Flask 示例)
from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/api/generate', methods=['POST'])
def generate():
    # 验证用户 token
    user_token = request.headers.get('Authorization')
    if not verify_user_token(user_token):
        return jsonify({"error": "Unauthorized"}), 401

    data = request.json

    # 后端调用 APIYI API (API Key 不会暴露给前端)
    response = requests.post(
        "http://api.apiyi.com:16888/v1/images/generations",
        json={
            "prompt": data['prompt'],
            "size": data['size'],
            "model": "nano-banana-pro",
            "n": 1,
            "response_format": "url"
        },
        headers={"Authorization": "Bearer YOUR_APIYI_API_KEY"},  # 安全存储在后端
        timeout=(10, 600)
    )

    result = response.json()
    return jsonify({"image_url": result['data'][0]['url']})

Resumen

Puntos clave de las llamadas síncronas y asíncronas de la API de Nano Banana Pro:

1. Características de la llamada síncrona: Mantiene la conexión HTTP hasta que se completa la generación, con una espera bloqueante de 30 a 170 segundos; requiere configurar un tiempo de espera largo (300-600 segundos).
2. Ventajas de la llamada asíncrona: Devuelve inmediatamente un ID de tarea, no es bloqueante y es ideal para el procesamiento por lotes y tareas en segundo plano. Sin embargo, actualmente ni APIYI ni Gemini oficial la admiten.
3. Salida de URL de OSS de APIYI: En comparación con la codificación base64, reduce el cuerpo de la respuesta en un 99.998%, admite aceleración por CDN y caché del navegador, lo que mejora significativamente el rendimiento.
4. Mejor práctica actual: Utilizar llamadas síncronas + concurrencia multihilo + salida de URL de OSS, obteniendo una configuración de tiempo de espera optimizada a través de la interfaz de puerto HTTP de APIYI.
5. Planes futuros: APIYI tiene previsto lanzar la función de llamada asíncrona en el segundo trimestre (Q2) de 2026, con soporte para envío de tareas, consulta de estado y callbacks Webhook.

Se recomienda integrar rápidamente la API de Nano Banana Pro a través de APIYI (apiyi.com). La plataforma ofrece una interfaz de puerto HTTP optimizada (http://api.apiyi.com:16888/v1), salida exclusiva de imágenes mediante URL de OSS y configuraciones de tiempo de espera razonables, ideales para escenarios de generación de imágenes en tiempo real y procesamiento por lotes.

Autor: Equipo Técnico de APIYI | Si tiene alguna duda técnica, le invitamos a visitar APIYI (apiyi.com) para obtener más soluciones de acceso a modelos de IA.