Tutorial completo de llamadas a la API de Nano Banana Pro: 44% más barato que KIE.ai, integración rápida en formato nativo de Google

作者注：详解 Nano Banana Pro API 调用方法，采用谷歌原生 Gemini 格式，通过 APIYI平台仅需 $0.05/次，比 KIE.ai 价格低 44%，支持 1K/2K/4K 分辨率图像生成。

调用 Nano Banana Pro API 时，很多开发者第一时间会选择 KIE.ai，但实际上还有更便宜、更稳定的选择。本文将介绍如何用 谷歌原生 Gemini API 格式 调用 Nano Banana Pro，并通过 APIYI平台将单次调用成本降至 $0.05——比 KIE.ai 低 44%。

核心价值：读完本文，你将掌握 Nano Banana Pro API 的标准调用方式，了解各平台价格差异，并能用最低成本生成专业级 4K 图像。

Resumen de parámetros principales de la API de Nano Banana Pro

¿Por qué Nano Banana Pro utiliza el formato nativo de Google?

Nano Banana Pro (nombre del modelo gemini-3-pro-image-preview) es un modelo de generación de imágenes de nivel profesional lanzado por Google DeepMind. El diseño de su API se basa en el protocolo nativo de Gemini, y existen diferencias fundamentales con el formato de OpenAI:

• Parámetros de modalidad de respuesta: Es necesario declarar responseModalities: ["IMAGE"] dentro de generationConfig, en lugar de usar el response_format de OpenAI.
• Control de resolución: Se especifica mediante el campo resolution (1K/2K/4K), en lugar de dimensiones en píxeles.
• Relación de aspecto: Utiliza una cadena de texto en aspectRatio (como "16:9"), en lugar de valores numéricos de ancho y alto.

Si intentas realizar la llamada usando el formato del SDK de OpenAI, te encontrarás con errores de análisis de parámetros. Lo correcto es utilizar el SDK de Google Generative AI o enviar peticiones HTTP directamente a los endpoints compatibles.

¿Qué puede generar Nano Banana Pro?

Este modelo destaca especialmente en los siguientes escenarios, superando con creces a sus competidores:

• Renderizado de texto multilingüe: Soporta la incrustación precisa de texto en varios idiomas, como chino, inglés y japonés, con fuentes claras y sin caracteres extraños.
• Infografías y visualización de datos: Capaz de generar infografías profesionales que incluyen gráficos, tablas y anotaciones de datos.
• Materiales de marketing: Pósteres, imágenes de producto y banners publicitarios con una disposición de texto precisa.
• Exhibición de productos: Iluminación física exacta, detalles de materiales y efectos de proyección realistas.
• Ilustraciones para presentaciones: Imágenes para diapositivas que cumplen con una estética profesional.

Comparativa de precios de la API de Nano Banana Pro por plataforma

Antes de elegir una plataforma, es importante entender las diferencias reales de costes entre ellas:

💰 Comparativa de costes: Calculando la generación de 100 imágenes 4K al día, el coste mensual oficial de Google es de unos $720, KIE.ai unos $360, mientras que a través de APIYI (apiyi.com) solo cuesta $150, lo que supone un ahorro mensual de más de $570.

Ventajas principales de APIYI frente a KIE.ai:

1. Precio más bajo: $0.05/vez frente a los $0.09/vez de KIE.ai, un ahorro del 44%.
2. Compatibilidad de formato: Soporta directamente el formato nativo de la API de Gemini de Google, sin necesidad de conversiones.
3. Mayor velocidad: Líneas de aceleración optimizadas, con una respuesta probada más estable.
4. Interfaz unificada: Soporta simultáneamente modelos principales como GPT, Claude y Gemini, facilitando el cambio entre modelos.

Guía rápida de la API de Nano Banana Pro

Método 1: Uso del SDK de Google Generative AI (Recomendado)

Instala el SDK:

pip install google-generativeai

Ejemplo de llamada más sencillo (texto a imagen, 10 líneas de código):

import google.generativeai as genai
import base64

genai.configure(
    api_key="YOUR_API_KEY",
    # Usando el endpoint de APIYI, el precio es de solo $0.05/vez
    client_options={"api_endpoint": "vip.apiyi.com"}
)

model = genai.GenerativeModel("gemini-3-pro-image-preview")
response = model.generate_content(
    "Un gato naranja sentado en un campo de girasoles, soleado, estilo realista, 4K HD",
    generation_config=genai.GenerationConfig(
        response_modalities=["IMAGE"],
        resolution="4K",
        aspect_ratio="16:9"
    )
)

# Guardar imagen
for part in response.candidates[0].content.parts:
    if part.inline_data:
        with open("output.png", "wb") as f:
            f.write(base64.b64decode(part.inline_data.data))
        print("Imagen guardada: output.png")

🚀 Inicio rápido: Tras registrarte en APIYI (apiyi.com), obtendrás tu API Key y saldo de prueba gratuito. Solo copia el código anterior, sustituye YOUR_API_KEY y ejecútalo, sin necesidad de configuraciones adicionales.

import google.generativeai as genai
import base64
import os
from pathlib import Path
from typing import Optional, List


def setup_client(api_key: str):
    """Inicializa el cliente de la API de Nano Banana Pro"""
    genai.configure(
        api_key=api_key,
        # A través de APIYI, el precio es de $0.05/vez, un 79% menos que el oficial
        client_options={"api_endpoint": "vip.apiyi.com"}
    )
    return genai.GenerativeModel("gemini-3-pro-image-preview")


def text_to_image(
    model,
    prompt: str,
    resolution: str = "2K",       # 1K / 2K / 4K
    aspect_ratio: str = "1:1",    # 1:1 / 16:9 / 9:16 / 4:3 / 3:4
    output_path: str = "output.png"
) -> str:
    """
    Texto a imagen: genera una imagen basada en una descripción textual

    Args:
        model: Instancia del modelo inicializada
        prompt: Descripción de la imagen (indicación)
        resolution: Resolución de salida 1K/2K/4K
        aspect_ratio: Relación de aspecto
        output_path: Ruta de guardado

    Returns:
        Ruta del archivo guardado
    """
    response = model.generate_content(
        prompt,
        generation_config=genai.GenerationConfig(
            response_modalities=["IMAGE"],
            resolution=resolution,
            aspect_ratio=aspect_ratio
        )
    )

    for part in response.candidates[0].content.parts:
        if part.inline_data and part.inline_data.mime_type.startswith("image/"):
            with open(output_path, "wb") as f:
                f.write(base64.b64decode(part.inline_data.data))
            return output_path

    raise ValueError("La API no devolvió datos de imagen, por favor revisa si el prompt activó algún filtro de contenido")


def image_to_image(
    model,
    prompt: str,
    reference_image_path: str,
    resolution: str = "2K",
    output_path: str = "edited_output.png"
) -> str:
    """
    Imagen a imagen: edición o transferencia de estilo basada en una imagen de referencia

    Args:
        model: Instancia del modelo inicializada
        prompt: Instrucción de edición (ej. "cambia el fondo a noche")
        reference_image_path: Ruta de la imagen de referencia
        resolution: Resolución de salida
        output_path: Ruta de guardado

    Returns:
        Ruta del archivo guardado
    """
    # Leer imagen de referencia
    with open(reference_image_path, "rb") as f:
        image_data = base64.b64encode(f.read()).decode()

    # Detectar formato de imagen
    ext = Path(reference_image_path).suffix.lower()
    mime_map = {".jpg": "image/jpeg", ".jpeg": "image/jpeg",
                ".png": "image/png", ".webp": "image/webp"}
    mime_type = mime_map.get(ext, "image/png")

    response = model.generate_content(
        [
            {"inline_data": {"mime_type": mime_type, "data": image_data}},
            prompt
        ],
        generation_config=genai.GenerationConfig(
            response_modalities=["IMAGE"],
            resolution=resolution
        )
    )

    for part in response.candidates[0].content.parts:
        if part.inline_data and part.inline_data.mime_type.startswith("image/"):
            with open(output_path, "wb") as f:
                f.write(base64.b64decode(part.inline_data.data))
            return output_path

    raise ValueError("Fallo en el procesamiento imagen a imagen, por favor confirma que el formato de la imagen de referencia es correcto")


def batch_generate(
    model,
    prompts: List[str],
    resolution: str = "2K",
    output_dir: str = "batch_output"
) -> List[str]:
    """
    Generación de imágenes por lotes

    Args:
        model: Instancia del modelo
        prompts: Lista de indicaciones (prompts)
        resolution: Resolución
        output_dir: Directorio de salida

    Returns:
        Lista de rutas de archivos generados
    """
    os.makedirs(output_dir, exist_ok=True)
    results = []

    for i, prompt in enumerate(prompts):
        output_path = f"{output_dir}/image_{i+1:03d}.png"
        try:
            path = text_to_image(model, prompt, resolution, output_path=output_path)
            results.append(path)
            print(f"[{i+1}/{len(prompts)}] Generación exitosa: {path}")
        except Exception as e:
            print(f"[{i+1}/{len(prompts)}] Error en generación: {e}")
            results.append(None)

    return results


# Ejemplo de uso
if __name__ == "__main__":
    # Inicializar cliente - Llamada a través de APIYI (apiyi.com), $0.05/vez
    model = setup_client("YOUR_APIYI_API_KEY")

    # Ejemplo de texto a imagen
    path = text_to_image(
        model,
        prompt="Imagen de exhibición de producto de estilo moderno y minimalista, fondo blanco, iluminación de estudio profesional, apta para comercio electrónico",
        resolution="4K",
        aspect_ratio="1:1",
        output_path="product_4k.png"
    )
    print(f"Imagen de producto 4K generada: {path}")

    # Ejemplo de imagen a imagen (modificar imagen existente)
    edited = image_to_image(
        model,
        prompt="Cambia el fondo de la imagen a un escenario natural al aire libre, manteniendo el sujeto principal intacto",
        reference_image_path="product_4k.png",
        resolution="4K",
        output_path="product_outdoor.png"
    )
    print(f"Imagen editada: {edited}")

Método 2: Uso de peticiones HTTP directas (apto para cualquier lenguaje)

Si no deseas instalar el SDK, también puedes enviar peticiones HTTP POST directamente:

import requests
import base64
import json

API_KEY = "YOUR_APIYI_API_KEY"
# Endpoint de APIYI compatible con el formato nativo de Google
BASE_URL = "https://vip.apiyi.com/v1beta/models/gemini-3-pro-image-preview:generateContent"

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

payload = {
    "contents": [
        {
            "role": "user",
            "parts": [
                {
                    "text": "Una sala de servidores de un centro de datos con aire tecnológico, efecto de luces de neón azules, 4K ultra claro, calidad cinematográfica"
                }
            ]
        }
    ],
    "generationConfig": {
        "responseModalities": ["IMAGE"],
        "resolution": "4K",
        "aspectRatio": "16:9"
    }
}

response = requests.post(BASE_URL, headers=headers, json=payload)
data = response.json()

# Extraer y guardar imagen
image_data = data["candidates"][0]["content"]["parts"][0]["inlineData"]["data"]
with open("datacenter_4k.png", "wb") as f:
    f.write(base64.b64decode(image_data))
print("¡Generación de imagen completada!")

Nota: El código anterior utiliza el endpoint compatible de APIYI (apiyi.com), que es totalmente compatible con el formato nativo de la API de Gemini de Google, sin necesidad de ninguna conversión de formato, a $0.05/vez.

Detalles de los parámetros principales de Nano Banana Pro

Tabla completa de parámetros de resolución y relación de aspecto

Relaciones de aspecto compatibles (valores del parámetro aspectRatio):

Horizontal: "16:9"  "4:3"  "3:2"  "21:9"
Cuadrado: "1:1"
Vertical: "9:16"  "3:4"  "2:3"  "9:21"
Personalizado: "4:5" (Recomendado para Instagram)

Mejores prácticas para indicaciones

Nano Banana Pro es muy sensible a la calidad de la indicación. Aquí tienes un patrón de escritura verificado:

Estructura de una indicación de alta calidad: Descripción del sujeto + Definición del estilo + Iluminación/Textura + Palabras de resolución/calidad

✅ Escritura recomendada:
"Una joven vestida con un hanfu tradicional de pie en un jardín clásico, 
 estilo de pintura meticulosa (Gongbi), luz natural suave, detalles ricos, 
 4K ultra claro, altamente realista"

❌ Qué evitar:
"Dibuja a una chica" (demasiado vago)

Indicaciones específicas para renderizado de texto (la ventaja principal de Nano Banana Pro):

"Un póster de evento, texto del título 'Cumbre AI 2026', 
 bilingüe chino-inglés, estilo de diseño moderno, fondo azul oscuro, 
 fuente del título blanca, texto claro y legible"

Casos de uso reales de la API de Nano Banana Pro

Escenario 1: Generación por lotes de imágenes de productos para e-commerce

# Generación por lotes de imágenes de exhibición de productos
product_prompts = [
    "Auriculares inalámbricos Bluetooth, fondo blanco puro, fotografía de producto profesional, vista frontal, 4K",
    "Auriculares inalámbricos Bluetooth, fondo gris oscuro, vista lateral de 45 grados, muestra detalles de los auriculares, 4K",
    "Auriculares inalámbricos Bluetooth, escena de estilo de vida, imagen de uso, luz solar exterior, 4K"
]

results = batch_generate(
    model,
    product_prompts,
    resolution="4K",
    output_dir="product_images"
)
# 3 imágenes, costo total en APIYI: $0.15 (en KIE.ai costaría $0.27)

Escenario 2: Diseño de texto en pósteres de marketing

Una de las capacidades más destacadas de Nano Banana Pro es renderizar texto con precisión dentro de las imágenes, algo que a modelos similares les cuesta mucho lograr:

poster_prompt = """
Diseña un póster de promoción para el 11.11:
- Título: Gran Promoción 11.11
- Subtítulo: Hasta 50% de descuento
- Fondo: Degradado rojo, estilo festivo
- Color de texto: Dorado, fuente grande y llamativa
- Pie: Fecha del evento 2026.11.11-11.13
Requisito: Texto claro y legible, diseño profesional
"""

path = text_to_image(model, poster_prompt, resolution="4K", aspect_ratio="9:16")
# Póster vertical para móvil, $0.05/imagen

💡 Sugerencia de escenario: Para casos que requieren generar imágenes a gran escala (como fotos de productos de e-commerce o materiales de marketing), se recomienda realizar las llamadas a través de la plataforma APIYI (apiyi.com). No solo ofrece el precio más bajo, sino que también proporciona registros de llamadas detallados y estadísticas de uso, lo que facilita el control de costos.

Escenario 3: Integración en proyectos Node.js / TypeScript

Si tu proyecto utiliza JavaScript/TypeScript, puedes integrarlo directamente mediante peticiones HTTP:

import axios from "axios";
import * as fs from "fs";

const API_KEY = "TU_API_KEY_DE_APIYI";
// APIYI es compatible con el formato original de Google, precio $0.05/uso
const BASE_URL = "https://vip.apiyi.com/v1beta/models/gemini-3-pro-image-preview:generateContent";

interface GenerateImageOptions {
  prompt: string;
  resolution?: "1K" | "2K" | "4K";
  aspectRatio?: string;
  outputPath?: string;
}

async function generateImage({
  prompt,
  resolution = "2K",
  aspectRatio = "1:1",
  outputPath = "output.png",
}: GenerateImageOptions): Promise<string> {
  const response = await axios.post(
    BASE_URL,
    {
      contents: [{ role: "user", parts: [{ text: prompt }] }],
      generationConfig: {
        responseModalities: ["IMAGE"],
        resolution,
        aspectRatio,
      },
    },
    {
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${API_KEY}`,
      },
    }
  );

  const imageData =
    response.data.candidates[0].content.parts[0].inlineData.data;
  fs.writeFileSync(outputPath, Buffer.from(imageData, "base64"));
  return outputPath;
}

// Ejemplo de uso
generateImage({
  prompt: "Página de inicio de App de estilo minimalista moderno, tema oscuro, gran sentido tecnológico, 4K",
  resolution: "4K",
  aspectRatio: "9:16",
  outputPath: "app_splash.png",
}).then((path) => console.log(`Generación completada: ${path}`));

Estrategias de optimización de costos

En proyectos reales, es muy importante controlar razonablemente los costos de las llamadas a la API de Nano Banana Pro:

🎯 Recomendación de elección: Para equipos de startups y desarrolladores individuales, se recomienda probar primero con la cuota gratuita en la plataforma APIYI (apiyi.com). Una vez verificado que la calidad de la imagen cumple con los requisitos, se puede escalar el uso. La plataforma ofrece pago por uso, sin límites de consumo mínimo.

Preguntas frecuentes

Resumen

Puntos clave para la llamada a la API de Nano Banana Pro:

1. Usa el formato nativo de Gemini: Es obligatorio usar el SDK google-generativeai o solicitudes HTTP nativas; el formato del SDK de OpenAI no es compatible.
2. Mejor precio en APIYI: $0.05 por solicitud, un 44% menos que KIE.ai ($0.09) y un 79% menos que el precio oficial de Google ($0.24).
3. 3 parámetros críticos: responseModalities: ["IMAGE"], resolution (1K/2K/4K) y aspectRatio.
4. El renderizado de texto es su mayor ventaja: Para pósteres de marketing, infografías y contenido bilingüe, Nano Banana Pro es actualmente la mejor opción.

Para equipos que requieren llamadas por lotes o despliegues en entornos de producción, se recomienda la integración a través de APIYI (apiyi.com). La plataforma es estable y ofrece registros detallados de la API y monitoreo de consumo, lo que ayuda a controlar con precisión los costos de generación de imágenes.

Referencias

1. Documentación de generación de imágenes de la API de Google Gemini

   • Enlace: ai.google.dev/gemini-api/docs/image-generation
   • Descripción: Especificaciones oficiales de los parámetros de la API y restricciones de uso para Nano Banana Pro.

2. SDK de Python para Google Generative AI

   • Enlace: github.com/google-gemini/generative-ai-python
   • Descripción: Instalación del SDK y referencia completa de la API; el código de este artículo se basa en este SDK.

3. Documentación de acceso a Nano Banana Pro en la plataforma APIYI

   • Enlace: docs.apiyi.com
   • Descripción: Detalles de precios y explicaciones de compatibilidad de APIYI con el formato nativo de Google.

Autor: Equipo técnico
Intercambio técnico: Te invitamos a compartir en la sección de comentarios las obras que hayas creado con Nano Banana Pro. Para descubrir más trucos sobre generación de imágenes con IA, visita la comunidad técnica de APIYI en apiyi.com.