Nano Banana API: Google y laozhang.ai, coste y entrega de imágenes

Para elegir una API de Nano Banana, compara el coste de recibir una imagen utilizable del mismo modelo y resolución. El precio anunciado no basta: Google desglosa el consumo y laozhang.ai publica una tarifa por llamada que puede cobrarse aunque no recibas una imagen. Tampoco hay datos de rendimiento independientes en esta comparación que permitan declarar cuál es más estable.

Con las tarifas revisadas el 7 de septiembre de 2026, laozhang.ai cuesta menos que la salida de imagen de Google Standard en los ejemplos de 1K y 4K de abajo. Google Batch puede resultar más barato para algunos trabajos que admiten espera. La elección cambia según el tamaño, la modalidad y cuántas llamadas acaban entregando el archivo que necesitas; no depende únicamente de quién ofrece el menor precio de portada.

Qué estás comparando exactamente

Nano Banana 2 corresponde a gemini-3.1-flash-image y Nano Banana Pro a gemini-3-pro-image. Son los identificadores actuales de las fichas de Nano Banana 2 y Nano Banana Pro. El Nano Banana original y las variantes Lite son modelos distintos: su tarifa no sirve para presupuestar Pro a 4K.

Google directo utiliza la API de Gemini con una clave de Google. laozhang.ai es un proveedor intermediario con su propia clave, dirección de API y facturación. Los dos pueden aceptar solicitudes con el formato de Google, lo que permite mantener el cuerpo de la petición y cambiar la dirección y la autenticación.

Las diferencias de facturación y conexión ayudan a elegir una integración, pero no prueban una diferencia de disponibilidad. Una API que responde correctamente sin adjuntar una imagen todavía no ha completado el trabajo de tu aplicación.

Cuánto cuestan las mismas imágenes

La tabla de Google cobra la salida de imagen por tokens. Sus equivalencias redondeadas por imagen en Standard son 0,045 / 0,067 / 0,101 / 0,151 USD para Nano Banana 2 a 0,5K / 1K / 2K / 4K. Para Pro son 0,134 USD a 1K o 2K y 0,24 USD a 4K. Estos importes cubren únicamente la salida de imagen: la entrada, otras salidas de texto o razonamiento y las funciones de búsqueda pueden añadir consumo.

La guía de imágenes de laozhang.ai publica 0,055 USD por llamada de Nano Banana 2 y 0,09 USD por llamada de Pro. La nota de facturación de su documentación de Pro indica que se basa en llamadas correctas a Google: una respuesta correcta sin imagen puede cobrarse. Por tanto, «1.000 llamadas cobradas» y «1.000 imágenes entregadas» no son cantidades intercambiables.

Esta tabla permite presupuestar sin multiplicar un precio unitario redondeado y presentarlo como una factura exacta:

Los totales de Google proceden de los tokens de imagen documentados: por ejemplo, Nano Banana 2 a 1K utiliza 1.120 tokens, a 60 USD por millón en Standard, de modo que 1.000 salidas cuestan 67,20 USD. Los totales de laozhang.ai multiplican su tarifa por 1.000 llamadas cobradas. No incluyen una conversión a euros ni una estimación fiscal.

La consecuencia práctica es concreta: para Nano Banana 2 a 1K, Google Batch tiene menor coste de salida que las 1.000 llamadas de laozhang.ai; a 4K, la comparación se invierte. Para Pro a 1K o 2K ocurre lo primero, y a 4K lo segundo. Al coste de Google aún hay que sumar los demás conceptos aplicables, y a ambas alternativas hay que exigir la misma entrega.

Cuándo sirve el descuento de Batch

Google documenta Batch como procesamiento asíncrono, con un 50 % de descuento y un objetivo de finalización de 24 horas. Puede encajar para preparar un catálogo durante la noche; no sustituye una petición interactiva cuyo usuario espera el resultado en pantalla.

Las fichas de los modelos indican que Flex y Priority no están disponibles, mientras que la página de precios de Pro incluye tarifas para esas modalidades. Esa discrepancia documental no demuestra que una llamada concreta vaya a aceptarse o rechazarse. Los cálculos anteriores se limitan a Standard y Batch, cuya disponibilidad está documentada para ambos modelos.

Para comparar la familia completa y las opciones gratuitas, consulta la guía de precios de Nano Banana API. Las salidas de imagen de los dos modelos aquí tratados no tienen una modalidad gratuita en la tabla de Google revisada.

Una solicitud que termina en un archivo comprobado

Usaremos Pro a 2K y formato cuadrado en las dos conexiones. La guía de Google para generar imágenes devuelve partes dentro de candidates[].content.parts[]; algunas pueden contener texto. La imagen aparece en inlineData, con su mimeType y sus datos en base64. Leer únicamente la primera parte puede perder una imagen válida.

La documentación de Pro de laozhang.ai admite el mismo formato. Conviene usarlo para seleccionar la proporción y pedir 2K o 4K: su modo Chat Completions está documentado con la limitación de 1:1 y 1K. No sustituyas esta dirección por /v1/images/generations suponiendo que será equivalente. Google también ofrece compatibilidad con OpenAI; la compatibilidad por sí sola no es una ventaja exclusiva del intermediario.

Guarda el siguiente programa como generar.py. Necesita Python 3 y Pillow, que puedes instalar con python3 -m pip install Pillow. Define API_PROVIDER como google o laozhang y proporciona la clave correspondiente mediante GOOGLE_API_KEY o LAOZHANG_API_KEY en tu entorno. Después ejecuta python3 generar.py: cada ejecución realiza una solicitud al proveedor seleccionado y puede generar un cargo.

import base64
import io
import json
import os
import uuid
from pathlib import Path
from urllib.request import Request, urlopen
from PIL import Image


def guardar_imagenes(respuesta, carpeta, dimensiones=(2048, 2048)):
    formatos = {"image/png": "PNG", "image/jpeg": "JPEG", "image/webp": "WEBP"}
    extensiones = {"PNG": ".png", "JPEG": ".jpg", "WEBP": ".webp"}
    verificadas = []
    for candidato in respuesta.get("candidates", []):
        for parte in candidato.get("content", {}).get("parts", []):
            if parte.get("thought"):
                continue
            datos = parte.get("inlineData")
            if not datos:
                continue
            esperado = formatos.get(datos.get("mimeType"))
            if esperado is None:
                raise ValueError("Formato de imagen no admitido")
            contenido = base64.b64decode(datos["data"], validate=True)
            with Image.open(io.BytesIO(contenido)) as imagen:
                if imagen.format != esperado:
                    raise ValueError("El archivo no coincide con su MIME")
                imagen.verify()
            with Image.open(io.BytesIO(contenido)) as imagen:
                imagen.load()
                if imagen.size != dimensiones:
                    raise ValueError(f"Dimensiones inesperadas: {imagen.size}")
            verificadas.append((contenido, extensiones[esperado]))
    if not verificadas:
        raise ValueError("La respuesta no contiene una imagen final")
    carpeta = Path(carpeta)
    carpeta.mkdir(parents=True, exist_ok=True)
    archivos = []
    for numero, (contenido, extension) in enumerate(verificadas, 1):
        archivo = carpeta / f"imagen-{numero}{extension}"
        with archivo.open("xb") as destino:
            destino.write(contenido)
        archivos.append(archivo)
    return archivos


def main():
    proveedor = os.environ.get("API_PROVIDER", "google")
    if proveedor == "google":
        base = "https://generativelanguage.googleapis.com"
        auth = {"x-goog-api-key": os.environ["GOOGLE_API_KEY"]}
    elif proveedor == "laozhang":
        base = "https://api2.laozhang.ai"
        auth = {"Authorization": "Bearer " + os.environ["LAOZHANG_API_KEY"]}
    else:
        raise ValueError("API_PROVIDER debe ser google o laozhang")
    modelo = "gemini-3-pro-image"
    cuerpo = {
        "contents": [{"parts": [{"text": "Un limonero en una terraza al amanecer"}]}],
        "generationConfig": {
            "responseModalities": ["IMAGE"],
            "imageConfig": {"aspectRatio": "1:1", "imageSize": "2K"},
        },
    }
    carpeta = Path("resultados") / uuid.uuid4().hex
    carpeta.mkdir(parents=True)
    solicitud = Request(
        f"{base}/v1beta/models/{modelo}:generateContent",
        data=json.dumps(cuerpo).encode("utf-8"),
        headers={"Content-Type": "application/json", **auth},
        method="POST",
    )
    with urlopen(solicitud, timeout=180) as respuesta:
        contenido = respuesta.read()
    (carpeta / "respuesta.json").write_bytes(contenido)
    archivos = guardar_imagenes(json.loads(contenido), carpeta)
    for archivo in archivos:
        print(archivo)


if __name__ == "__main__":
    main()

El programa guarda primero la respuesta recibida y después recorre todas las partes. Valida el base64, comprueba que el archivo se puede decodificar, contrasta su tipo con el MIME declarado y exige 2.048 × 2.048 píxeles para este ejemplo cuadrado a 2K. Solo entonces escribe las imágenes. La carpeta nueva evita sobrescribir resultados anteriores; conservar el JSON permite investigar una respuesta sin imagen. Protégelo como cualquier salida de tu aplicación.

Para Nano Banana 2 puedes sustituir el modelo por gemini-3.1-flash-image manteniendo esta configuración, según su documentación de laozhang.ai. Si cambias la resolución o la proporción, ajusta también las dimensiones esperadas en el validador. Abrir después el archivo permite comprobar el contenido: que se decodifique bien no significa que la composición o el texto cumplan el encargo.

La función de guardado se ha comprobado sin conexión, con respuestas e imágenes sintéticas: texto antes de la imagen, varias partes, respuesta solo de texto, base64 inválido, archivo truncado, MIME incorrecto y dimensiones equivocadas. Esa comprobación valida el ejemplo de análisis y guardado; no mide el tiempo de respuesta, la disponibilidad ni el cobro de las API. Para preparar credenciales y una integración más amplia, sigue la guía de conexión de Nano Banana API.

Qué hacer si la imagen no llega

Separa cuatro hechos en el registro de cada intento: respuesta HTTP, resultado de la generación, archivo guardado y cargo definitivo. Un HTTP 200 confirma una respuesta; un identificador de tarea permite consultar un trabajo asíncrono; una URL señala dónde buscar el resultado. Ninguno de ellos, por sí solo, confirma que tu aplicación haya recibido una imagen válida.

El ejemplo anterior es síncrono y no espera un identificador de tarea; la última fila se aplica si eliges una modalidad asíncrona. Ante un tiempo de espera agotado, reenviar inmediatamente puede crear una segunda generación y otro cargo. Si no puedes averiguar el estado, registra el intento como indeterminado y aplica una política explícita de espera o revisión. No presupongas que repetir la misma petición garantiza que solo se cobre una vez.

En laozhang.ai, contrasta los errores y los resultados sin imagen con el estado del pedido y el cargo final. No deduzcas un reembolso automático de un 429, un 5xx o de que tu cliente haya perdido la conexión. La regla de cobro por llamada correcta al servicio de Google hace especialmente importante conciliar el resultado técnico con la facturación.

Cómo decidir con tus propios resultados

La métrica de coste útil es importe neto finalmente cobrado ÷ imágenes aprovechables. Incluye cargos y devoluciones ya confirmados. Si no has obtenido ninguna imagen aprovechable, la división no está definida: presenta el gasto y las cero entregas, no un coste unitario de cero.

Por ejemplo, si 100 llamadas de Pro a laozhang.ai se cobran a 0,09 USD y 95 producen un archivo que cumple tu encargo, el coste es 9 ÷ 95 = 0,0947 USD por imagen aprovechable. Es un ejemplo aritmético, no una tasa de éxito medida. Si se cobran reintentos, también entran en el numerador.

Para evaluar la entrega, conserva por intento el proveedor, modelo, resolución, proporción, número de intento, estado HTTP, motivo de finalización, resultado de validación y cargo conciliado. Mide el tiempo desde que envías la solicitud hasta que el archivo queda guardado y comprobado. Si publicas un percentil 95, indica la ventana y cuántas entregas lo forman; comunica aparte los tiempos de espera agotados para que los fallos lentos no desaparezcan de la comparación.

Con esos datos, la decisión puede ser sencilla. Google directo encaja si quieres gestionar tu proyecto y facturación con Google; Batch merece una evaluación separada cuando la espera sea aceptable. laozhang.ai puede reducir el coste publicado de determinadas combinaciones de modelo y tamaño y permitir una conexión común con otros modelos, siempre contrastando su tarifa por llamada con las entregas que obtienes.

Mantener dos proveedores solo aporta una recuperación útil si has verificado que el segundo puede atender la misma solicitud cuando falla el primero. Ambos pueden depender del mismo servicio de Google y fallar a la vez. Batch tampoco es un respaldo inmediato. Antes de añadir otra integración, comprueba si el problema se resuelve ajustando la concurrencia, el tiempo de espera o los límites del proyecto de Gemini, que Google aplica por proyecto y no por clave.

La opción adecuada será la que entregue tu especificación dentro del plazo aceptable y con un coste conciliado que puedas sostener. Los precios anteriores sirven para elaborar ese presupuesto; el archivo recibido y el cargo final permiten comprobarlo.