Nano Banana 2 Lite vs 2.1 vs Pro: los modelos de imagen de Google Flow comparados

7 min de lectura • 2 de julio de 2026 (6 de noviembre de 2026)

useapi.net es una API de terceros. No está afiliada a Google ni cuenta con su respaldo.

Índice

  1. Introducción
  2. ¿Cuáles son los tres modelos Nano Banana?
    1. Escalado a 2K/4K
  3. Precios
  4. El prompt de la comparación
  5. Genera con los tres modelos
  6. Ejemplos
  7. ¿Qué modelo Nano Banana deberías usar?
  8. Ejecútalo tú mismo
  9. Preguntas frecuentes
  10. Conclusión

Introducción

Google Flow ofrece tres modelos de imagen Nano Banana, nano-banana-2-lite, nano-banana-2 y nano-banana-pro, y la Google Flow API de useapi.net ejecuta los tres a partir de un solo prompt con tu cuenta de Google Flow. Las imágenes están incluidas en todas las suscripciones de Google AI, también en una cuenta gratuita, mientras que la Gemini API oficial cobra de US$0,034 a US$0,134 por imagen (a noviembre de 2026). No necesitas proyecto de Google Cloud ni clave de API.

Esta guía ejecuta exactamente el mismo prompt en Lite, 2.1 y Pro para que veas en qué se diferencian, y luego te da un script de Node.js que genera el conjunto completo con un solo comando. ¿Prefieres empezar desde cero? Consulta el tutorial de generación de imágenes, la guía hermana de esta.

¿Cuáles son los tres modelos Nano Banana?

Elige el modelo en cada solicitud con el campo model. Si lo omites, Google Flow usa nano-banana-2-lite, su modelo por defecto desde julio de 2026. Los tres funcionan en cualquier suscripción de Google AI, incluida una cuenta gratuita.

ID del modelo Nombre comercial Ideal para Referencias (I2I) Velocidad
nano-banana-2-lite (por defecto) Nano Banana 2 Lite / Gemini 3.1 Flash-Lite Image imágenes rápidas y en gran volumen, en cualquier plan hasta 10 la más rápida
nano-banana-2 Nano Banana 2.1 equilibrio entre calidad y velocidad hasta 10 rápida
nano-banana-pro Nano Banana Pro / Gemini 3 Pro Image máxima fidelidad y apego a las instrucciones hasta 10 más lenta

Los tres aceptan las mismas relaciones de aspecto (16:9, 4:3, 1:1, 3:4, 9:16, más auto en el modo imagen a imagen), count (1–4), seed para reproducir resultados, hasta 10 imágenes de referencia, menciones con @ dentro del prompt y escalado a 2K/4K. Los alias obsoletos imagen-4 (Google quitó Imagen de Google Flow en julio de 2026) y nano-banana se siguen aceptando y corresponden a nano-banana-2-lite y nano-banana-2, respectivamente. El detalle completo de cada modelo está en la referencia de POST /images.

Escalado a 2K/4K

Cualquier imagen generada se puede escalar con POST /images/upscale: pasa su mediaGenerationId y un resolution de 2k (por defecto) o 4k. La respuesta llega en base64 en encodedImage. 2k funciona en cualquier plan, y 4k requiere Google AI Ultra.

Precios

Las imágenes no gastan créditos de Flow en ninguna suscripción de Google AI, incluida una cuenta gratuita, y useapi.net no cobra nada por imagen. El precio de cada modelo en cada plan, frente a la API oficial, está en la tabla de precios de Google Flow. Consulta la guía de configuración para conectar tu cuenta.

El prompt de la comparación

Una comparación de modelos solo sirve si el prompt es difícil. Este es una escena absurda a propósito, en un solo cuadro, que pone a prueba varias cosas a la vez: un estilo fotográfico con nombre (David LaChapelle), una disposición espacial con varios sujetos (un enjambre que forma una flecha arriba a la izquierda y una abeja en perspectiva forzada abajo a la derecha), la fidelidad de un objeto (un panal que gotea miel), una expresión cómica concreta (ojos de caricatura o_O) y un tono contradictorio, todo en una sola imagen coherente.

A visually breathtaking, beautifully absurd, single-frame photograph in the hyper-saturated,
glossy, surreal-comedy editorial style of David LaChapelle, shot at a sun-dappled backyard
apiary at golden hour on an 85mm f/1.4 lens with creamy shallow depth of field. In the center
midground, a gorgeous, radiant young woman beekeeper with an elegant figure, flawless glowing
sun-kissed skin and a warm playful smile, incongruously wearing a tiny mini bikini and a
beekeeper's veil hat pushed back off her face, stands among the wooden hive boxes on the grass and lifts a single
open beehive frame heavy with golden honeycomb, thick honey oozing and stringing down in glossy
ribbons and catching the light. She looks directly into the camera, delighted and completely
unbothered by the bees swirling around her. In the top-left of the frame, a dense swarm of bees
bunches together and organizes into a bold, unmistakable arrow / pointer shape aimed straight at
her, as if frantically calling everyone's attention. In the extreme bottom-right foreground of
the exact same scene, photobombing the lens, is a huge forced-perspective close-up of a single
frazzled worker bee, staring directly into the camera with bulging, mind-blown "o_O" cartoon
googly eyes, completely frozen in comical disbelief. Single cohesive image, seamless depth of
field, no cut-ins, warm dynamic backlighting, glistening honey highlights, crazy situational
comedy, hyper-detailed, masterpiece.

Genera con los tres modelos

Necesitas un token de API de useapi.net y una cuenta de Google Flow conectada. POST /images es síncrono: una llamada espera hasta que las imágenes estén listas (normalmente de 20 a 60 segundos, y el modelo Pro puede tardar unos 2 minutos con mucha carga) y devuelve un arreglo media[] con una entrada por imagen, así que no hay jobid que consultar.

Una sola llamada, cambia model para comparar:

curl -X POST "https://api.useapi.net/v1/google-flow/images" \
  -H "Authorization: Bearer $USEAPI_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nano-banana-pro",
    "aspectRatio": "9:16",
    "count": 4,
    "prompt": "A beekeeper at golden hour lifting a dripping honeycomb frame, a swarm forming an arrow in the sky, a forced-perspective bee with o_O googly eyes in the foreground"
  }' > result.json

# cada imagen está en .media[N].image.generatedImage.fifeUrl
curl -o pro_1.jpg "$(jq -r '.media[0].image.generatedImage.fifeUrl' result.json)"

Para ejecutar la comparación completa con un solo comando, el script de Node.js de abajo lee prompts.json (una entrada por modelo, todas con el mismo prompt), envía cada una y guarda cada imagen devuelta con el nombre del modelo en el archivo: la descarga desde fifeUrl o decodifica el encodedImage en línea cuando falta la URL. Si una imagen falla, queda registrada en el log y la ejecución continúa. Necesitas Node.js v21 o superior. Pon los dos archivos en una carpeta y ejecuta node ./google-flow-nano-banana-compare.mjs API_TOKEN EMAIL, donde API_TOKEN es tu token de API de useapi.net y EMAIL es tu cuenta de Google Flow conectada. El script busca la cuenta por el correo, revisa su health antes de enviar y no envía captchaToken: el worker de useapi.net resuelve el reCAPTCHA automáticamente.

¿Prefieres clonarlo y ejecutarlo? El script completo, una versión en Python y prompts.json están en GitHub, en useapi/google-flow-api.

Abrir prompts.json 
[
    {
        "model": "nano-banana-2-lite",
        "aspectRatio": "9:16",
        "count": 4,
        "prompt": "A beekeeper at golden hour lifting a dripping honeycomb frame in the surreal editorial style of David LaChapelle, a dense bee swarm forming a bold arrow in the top-left, a forced-perspective bee with o_O cartoon googly eyes photobombing the bottom-right. Single cohesive image, masterpiece."
    },
    {
        "model": "nano-banana-2",
        "aspectRatio": "9:16",
        "count": 4,
        "prompt": "A beekeeper at golden hour lifting a dripping honeycomb frame in the surreal editorial style of David LaChapelle, a dense bee swarm forming a bold arrow in the top-left, a forced-perspective bee with o_O cartoon googly eyes photobombing the bottom-right. Single cohesive image, masterpiece."
    },
    {
        "model": "nano-banana-pro",
        "aspectRatio": "9:16",
        "count": 4,
        "prompt": "A beekeeper at golden hour lifting a dripping honeycomb frame in the surreal editorial style of David LaChapelle, a dense bee swarm forming a bold arrow in the top-left, a forced-perspective bee with o_O cartoon googly eyes photobombing the bottom-right. Single cohesive image, masterpiece."
    }
]
Abrir el script google-flow-nano-banana-compare.mjs 
/*

Script version 1.1, September 11, 2026

Batch-compare Google Flow's Nano Banana image models (2 Lite, 2.1, Pro) with the useapi.net API 🚀
Reads prompts.json (one entry per model), submits each to the synchronous POST /images endpoint,
and downloads every returned image with a model-labeled filename.
For more details visit https://useapi.net/docs/api-google-flow-v1/post-google-flow-images

Companion tutorial:
  https://useapi.net/docs/articles/google-flow-nano-banana-compare

Installation Instructions:
==========================

You need Node.js v21 or newer installed to run this script. Download and install Node.js from:

- Windows, macOS, Linux: https://nodejs.org/

After installation, verify by running the following command in a terminal:

   node -v

Running the Script:
===================

Usage: node google-flow-nano-banana-compare.mjs <API_TOKEN> <EMAIL> [PROMPTS_FILE]

Replace API_TOKEN with your actual useapi.net API token, see https://useapi.net/docs/start-here/setup-useapi
Replace EMAIL with configured Google Flow email account, see https://useapi.net/docs/start-here/setup-google-flow
If optional PROMPTS_FILE not provided prompts.json will be used.

Example:
--------

node google-flow-nano-banana-compare.mjs user:1234-abcdefhijklmnopqrstuv [email protected]

Changelog:
==========

- July 2, 2026: Initial release.
- September 11, 2026: Saves encodedImage when fifeUrl is absent, and writes a downloaded image only once it has been fully received, so a failed download leaves no partial file for the next run to skip as "already exists".

*/

import fs from 'fs/promises';
import { writeFile } from 'node:fs/promises';

// Constants
const DEFAULT_PROMPTS_FILE = 'prompts.json';
const DEFAULT_MODEL = 'nano-banana-2-lite';
const SLEEP_RETRY = 30 * 1000; // in milliseconds

const urlAccounts = 'https://api.useapi.net/v1/google-flow/accounts';
const urlImages = 'https://api.useapi.net/v1/google-flow/images';

// Utility to sleep for given milliseconds
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
const elapsedTimeSec = (start) => (Date.now() - start) / 1000;

// Function to fetch configured Google Flow API accounts
async function fetchAccounts(apiToken) {
    const response = await fetch(urlAccounts, {
        headers: {
            'Accept': 'application/json',
            'Authorization': `Bearer ${apiToken}`
        }
    });

    if (!response.ok) {
        console.error(`⛔ Error fetching accounts (HTTP ${response.status}): ${response.statusText}`);
        process.exit(1);
    }

    return response.json();
}

// Save a single image from its signed fifeUrl. fifeUrl is normally present; when it is absent
// the image arrived inline as base64 in encodedImage. A failure is reported and skipped.
async function downloadImage(img, filename) {
    try {
        await fs.access(filename);
        console.log(`⚠️ ${filename} already exists. Skipping download.`);
        return;
    } catch {
        // File does not exist, proceed with downloading
    }

    const url = img?.fifeUrl;

    if (!url && img?.encodedImage) {
        console.log(`✅ Saving ${filename} from encodedImage`);
        try {
            await writeFile(filename, Buffer.from(img.encodedImage, 'base64'));
        } catch (err) {
            console.error(`⛔ Unable to save ${filename}: ${err}`);
        }
        return;
    }

    if (!url) {
        console.error(`🛑 No fifeUrl or encodedImage for ${filename}`);
        return;
    }

    console.log(`✅ Downloading ${filename}`);
    try {
        const imageResponse = await fetch(url);
        if (!imageResponse.ok) {
            console.error(`⛔ Unable to download ${filename} (HTTP ${imageResponse.status})`);
            return;
        }
        // Read the whole body before creating the file, so a failed download leaves no
        // partial file behind for the next run to skip as "already exists".
        const data = Buffer.from(await imageResponse.arrayBuffer());
        await writeFile(filename, data);
    } catch (err) {
        console.error(`⛔ Error during download: ${err}`);
    }
}

// Submit a single prompt to the synchronous POST /images endpoint and download the results.
async function submitImage(apiToken, email, prompt, index) {
    const model = prompt.model ?? DEFAULT_MODEL;

    // Build the request body.
    const body = { model, email, prompt: prompt.prompt };
    for (const key of ['aspectRatio', 'count', 'seed'])
        if (prompt[key] !== undefined) body[key] = prompt[key];

    console.log(`🚀 ${model} » Prompt #${index} • account ${email} …`);
    const startTime = Date.now();

    while (true) {
        const response = await fetch(urlImages, {
            method: 'POST',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${apiToken}`
            },
            body: JSON.stringify(body)
        });

        const responseText = await response.text();

        if (response.status == 200) {
            const media = JSON.parse(responseText)?.media ?? [];

            if (media.length == 0)
                console.error(`🛑 200 OK but no media (moderated?) for ${model}`);

            // count > 1 returns multiple images in the media array.
            for (let i = 0; i < media.length; i++) {
                const img = media[i]?.image?.generatedImage;
                await downloadImage(img, `${model}_${i + 1}.jpg`);
            }
            console.log(`🆗 ${model} done (${elapsedTimeSec(startTime)} sec)`);
            return 200;
        }

        switch (response.status) {
            case 429:
            case 503:
                console.log(`🔄️ Retry on HTTP ${response.status}`, responseText);
                await sleep(SLEEP_RETRY);
                break;
            default:
                console.error(`🛑 ${model} failed with HTTP ${response.status}`, responseText);
                return response.status;
        }
    }
}

// Main function
async function main() {
    const apiToken = process.argv[2];
    const email = process.argv[3];
    const promptFile = process.argv[4] || DEFAULT_PROMPTS_FILE;

    if (!apiToken || !email) {
        console.error('Usage: node google-flow-nano-banana-compare.mjs <API_TOKEN> <EMAIL> [PROMPTS_FILE]');
        process.exit(1);
    }

    console.info('Script v1.1 • Node version ' + process.version);

    const accounts = await fetchAccounts(apiToken);

    if (!accounts[email]) {
        console.error(`⛔ Account ${email} not found. Please refer to https://useapi.net/docs/start-here/setup-google-flow`);
        process.exit(1);
    }

    if (accounts[email].health && accounts[email].health !== 'OK') {
        console.error(`⛔ Account ${email} health is '${accounts[email].health}'. Please resolve and update the account, see https://useapi.net/docs/start-here/setup-google-flow`);
        process.exit(1);
    }

    const prompts = JSON.parse(await fs.readFile(promptFile, 'utf8'));
    console.log(`Comparing ${prompts.length} model runs …`);

    const start = new Date();
    for (let i = 0; i < prompts.length; i++)
        await submitImage(apiToken, email, prompts[i], i + 1);

    console.info('COMPLETED', new Date(), '• elapsed', elapsedTimeSec(start), 'sec');
}

main();

Ejemplos

Este es el mismo prompt de la apicultora generado por cada modelo en 9:16, con esta Google Flow API. Las diferencias se repiten: Pro es el más pulido y el más fiel a las instrucciones, 2.1 es el más dinámico y Lite es el más rápido y queda muy cerca.

nano-banana-pro: el más pulido y con más aire editorial, y el único modelo que dibuja siempre la malla del velo, las abejas caminando sobre el panal y los ojos de caricatura o_O al pie de la letra.

Apicultora generada con Nano Banana Pro mediante la Google Flow API

nano-banana-2: la interpretación más dinámica y llena de energía, con el enjambre en forma de flecha más claro y muchos detalles de la situación (botas de trabajo, abejas en el cuadro).

Apicultora generada con nano-banana-2 mediante la Google Flow API

nano-banana-2-lite: el más rápido de los tres (cerca de la mitad del tiempo de Pro en nuestras pruebas), y conserva la composición, la miel que gotea y la abeja de ojos saltones en primer plano.

Apicultora generada con Nano Banana 2 Lite mediante la Google Flow API

¿Qué modelo Nano Banana deberías usar?

  • Usa nano-banana-pro cuando la fidelidad es lo que más importa: imágenes principales, escenas complejas con varios sujetos, texto preciso o apego estricto a las instrucciones. Es el más lento de los tres.
  • Usa nano-banana-2 para un buen equilibrio entre calidad y velocidad, o cuando quieres una lectura del prompt más dinámica y estilizada.
  • Usa nano-banana-2-lite (el modelo por defecto) para iterar y para lotes grandes en los que importa la velocidad y la calidad sigue muy cerca.

Como los tres usan la misma solicitud, cambiar es modificar una palabra en model: genera un lote con los tres y elige el mejor, tal como hace el script de arriba.

Ejecútalo tú mismo

El script completo de Node.js, una versión en Python y prompts.json están en useapi/google-flow-api/nano-banana-compare. Clónalo, edita prompts.json y ejecuta un comando para generar el conjunto completo de la comparación con tu cuenta de Google Flow.

Preguntas frecuentes

  • ¿Existe una API de Nano Banana 2.1 o de Nano Banana Pro? Con useapi.net, sí: la Google Flow API ejecuta las versiones de Google Flow como nano-banana-2 (Nano Banana 2.1), nano-banana-2-lite y nano-banana-pro en POST /images. En la Gemini API oficial, Nano Banana 2.1 cuesta unos US$0,034 por imagen 1K y Nano Banana Pro US$0,134 por imagen, frente a ningún cargo por imagen aquí (a noviembre de 2026).
  • ¿Qué diferencia hay entre Nano Banana 2 Lite, 2.1 y Pro? Con useapi.net los tres funcionan en el mismo endpoint, cada uno con su punto fuerte. nano-banana-pro (Gemini 3 Pro Image) es el más pulido y el que sigue las instrucciones más de cerca, nano-banana-2 (Nano Banana 2.1) da la lectura más dinámica, y nano-banana-2-lite (Gemini 3.1 Flash-Lite Image), el modelo por defecto, tardó cerca de la mitad del tiempo de Pro en nuestras pruebas. Consulta ¿Qué modelo deberías usar?
  • ¿Cuánto cuesta la API de Nano Banana? Con useapi.net, las imágenes no gastan créditos de Flow en ninguna suscripción de Google AI, incluida una cuenta gratuita, y no hay clave de la Gemini API ni cuenta de facturación de Cloud que configurar. En la Gemini API oficial, Nano Banana 2 Lite cuesta unos US$0,034 por imagen 1K (a noviembre de 2026). Consulta Precios.
  • ¿Las imágenes pasan por moderación? Con useapi.net, tus prompts pasan por la moderación de contenido del propio Google, y una solicitud rechazada devuelve un resultado vacío. Las decisiones de moderación varían entre solicitudes y entre modelos, así que reintentar, editar el prompt o cambiar de modelo suele funcionar, porque cada modelo Nano Banana modera de forma un poco distinta.
  • ¿Necesito un captcha o un proyecto de Google Cloud? Con useapi.net no necesitas proyecto de Google Cloud ni resolver captchas por tu cuenta. Google Flow pide un reCAPTCHA en cada imagen, y el worker de useapi.net lo resuelve automáticamente: tu primera cuenta de Google Flow incluye 300 resoluciones gratis con nuestras propias claves de AntiCaptcha, CapSolver y EzCaptcha, y después agregas las claves de tu propio proveedor. El script de esta guía no envía captchaToken.

Conclusión

Visita nuestro servidor de Discord o nuestro canal de Telegram para cualquier pregunta de soporte.

Consulta nuestro repositorio de GitHub con ejemplos de código.

Publicado también en

También publicado en dev.to (en inglés) y comentado en Reddit (en inglés).

Empieza a usar la API

Una sola suscripción de US$15 al mes cubre todas las API de useapi.net: un token para todos los servicios. Conectas hasta 3 cuentas propias por servicio, cada una con la suscripción de su sitio web, y useapi.net se encarga de la API REST, el balanceo de carga y el polling. ¿Necesitas más cuentas? Cada suscripción adicional cuesta US$10 al mes y suma 3 cuentas más por servicio.

Suscríbete — US$15/mes Pagar con cripto

¿No tienes una tarjeta de crédito internacional? También puedes suscribirte con criptomonedas (los pagos con cripto no se reembolsan). Los precios y los planes por volumen están en la página de suscripción. Si pagas con Stripe, recibes el reembolso completo dentro de los 14 días posteriores a la primera compra, si tienes menos de 50 generaciones exitosas. ¿Ya tienes una suscripción? Cambia la cantidad en el portal de clientes de Stripe en lugar de volver a comprar.