Nano Banana 2 Lite vs 2.1 vs Pro: os modelos de imagem do Google Flow comparados

7 min de leitura • 2 de julho de 2026 (6 de novembro de 2026)

A useapi.net é uma API de terceiros. Não tem afiliação com o Google nem é endossada por ele.

Sumário

  1. Introdução
  2. Quais são os três modelos Nano Banana?
    1. Upscale para 2K/4K
  3. Preços
  4. O prompt da comparação
  5. Gere com os três modelos
  6. Exemplos
  7. Qual modelo Nano Banana usar?
  8. Rode você mesmo
  9. Perguntas frequentes
  10. Conclusão

Introdução

O Google Flow oferece três modelos de imagem Nano Banana, nano-banana-2-lite, nano-banana-2 e nano-banana-pro, e a Google Flow API da useapi.net roda os três a partir de um único prompt com a sua conta do Google Flow. As imagens estão incluídas em toda assinatura do Google AI, até numa conta gratuita, enquanto a Gemini API oficial cobra de $0,034 a $0,134 por imagem (em novembro de 2026). Não precisa de projeto no Google Cloud nem de chave de API.

Este guia roda exatamente o mesmo prompt no Lite, no 2.1 e no Pro para você ver como eles diferem, e depois entrega um script em Node.js que gera o conjunto inteiro com um só comando. Quer primeiro um passo a passo do zero? Veja o tutorial de geração de imagens, o guia irmão deste.

Quais são os três modelos Nano Banana?

Escolha o modelo em cada requisição com o campo model. Se você o omitir, o Google Flow usa o nano-banana-2-lite, o padrão dele desde julho de 2026. Os três rodam em qualquer assinatura do Google AI, inclusive numa conta gratuita.

ID do modelo Nome comercial Melhor para Referências (I2I) Velocidade
nano-banana-2-lite (padrão) Nano Banana 2 Lite / Gemini 3.1 Flash-Lite Image imagens rápidas e em grande volume, em qualquer plano até 10 a mais rápida
nano-banana-2 Nano Banana 2.1 equilíbrio entre qualidade e velocidade até 10 rápida
nano-banana-pro Nano Banana Pro / Gemini 3 Pro Image máxima fidelidade e respeito às instruções até 10 mais lenta

Os três aceitam as mesmas proporções (16:9, 4:3, 1:1, 3:4, 9:16, mais auto no modo imagem para imagem), count (1–4), seed para reprodutibilidade, até 10 imagens de referência, @-menções inline e upscale para 2K/4K. Os aliases obsoletos imagen-4 (o Google removeu o Imagen do Google Flow em julho de 2026) e nano-banana continuam aceitos e correspondem a nano-banana-2-lite e nano-banana-2, respectivamente. Os detalhes completos de cada modelo estão na referência de POST /images.

Upscale para 2K/4K

Qualquer imagem gerada pode passar por upscale com POST /images/upscale: passe o mediaGenerationId dela e um resolution de 2k (padrão) ou 4k. A resposta vem em base64 no encodedImage. O 2k funciona em qualquer plano, e o 4k exige o Google AI Ultra.

Preços

As imagens não consomem créditos do Flow em nenhuma assinatura do Google AI, inclusive numa conta gratuita, e a useapi.net não cobra nada por imagem. O preço de cada modelo em cada plano, comparado com a API oficial, está na tabela de preços do Google Flow. Veja o guia de configuração para conectar a sua conta.

O prompt da comparação

Uma comparação de modelos só serve se o prompt for difícil. Este é uma cena absurda de propósito, num único quadro, que testa várias coisas ao mesmo tempo: um estilo fotográfico com nome (David LaChapelle), um layout espacial com vários sujeitos (um enxame formando uma seta no canto superior esquerdo, uma abelha em perspectiva forçada no canto inferior direito), a fidelidade de um objeto (um favo pingando mel), uma expressão cômica específica (olhos de desenho o_O) e um tom contraditório, tudo numa única imagem coesa.

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.

Gere com os três modelos

Você precisa de um token de API da useapi.net e de uma conta do Google Flow conectada. O POST /images é síncrono: uma chamada espera até as imagens ficarem prontas (normalmente de 20 a 60 segundos, e o modelo Pro pode levar até uns 2 minutos sob carga) e devolve um array media[] com uma entrada por imagem, então não há jobid para consultar.

Uma única chamada, troque o 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 imagem fica em .media[N].image.generatedImage.fifeUrl
curl -o pro_1.jpg "$(jq -r '.media[0].image.generatedImage.fifeUrl' result.json)"

Para rodar a comparação inteira com um só comando, o script em Node.js abaixo lê o prompts.json (uma entrada por modelo, todas com o mesmo prompt), envia cada uma e salva cada imagem devolvida com o nome do modelo no arquivo, baixando-a do fifeUrl ou decodificando o encodedImage inline quando a URL não vem. Uma imagem que falha é registrada no log e o script segue em frente. Você precisa do Node.js v21+. Coloque os dois arquivos numa pasta e rode node ./google-flow-nano-banana-compare.mjs API_TOKEN EMAIL, em que API_TOKEN é o seu token de API da useapi.net e EMAIL é a sua conta do Google Flow conectada. O script procura a conta pelo e-mail, confere o health dela antes de enviar e não manda captchaToken: o worker da useapi.net resolve o reCAPTCHA automaticamente.

Prefere clonar e rodar? O script completo, uma versão em Python e o prompts.json estão no GitHub em 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 o 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();

Exemplos

Aqui está o mesmo prompt da apicultora gerado por cada modelo em 9:16, por esta Google Flow API. As diferenças se repetem: o Pro é o mais caprichado e o mais fiel às instruções, o 2.1 é o mais dinâmico e o Lite é o mais rápido e fica bem perto.

nano-banana-pro: o mais caprichado, com cara de editorial, e o único modelo que acerta sempre a tela do véu, as abelhas andando no favo e os olhos de desenho o_O ao pé da letra.

Apicultora gerada pelo Nano Banana Pro pela Google Flow API

nano-banana-2: a interpretação mais dinâmica e cheia de energia, com o enxame em forma de seta mais nítido e muitos detalhes da situação (botas de trabalho, abelhas no quadro).

Apicultora gerada pelo nano-banana-2 pela Google Flow API

nano-banana-2-lite: o mais rápido dos três (cerca de metade do tempo do Pro nos nossos testes), mantendo a composição, o mel escorrendo e a abelha de olhos esbugalhados em primeiro plano.

Apicultora gerada pelo Nano Banana 2 Lite pela Google Flow API

Qual modelo Nano Banana usar?

  • Use o nano-banana-pro quando a fidelidade é o que mais importa: imagens principais, cenas complexas com vários sujeitos, texto preciso ou respeito rigoroso às instruções. Ele é o mais lento dos três.
  • Use o nano-banana-2 para um bom equilíbrio entre qualidade e velocidade, ou quando você quer uma leitura mais dinâmica e estilizada do prompt.
  • Use o nano-banana-2-lite (o padrão) para iterar e para lotes grandes em que a velocidade importa e a qualidade continua muito próxima.

Como os três usam a mesma requisição, trocar é mudar uma palavra no model: gere um lote com os três e escolha o melhor, exatamente como o script acima faz.

Rode você mesmo

O script completo em Node.js, uma versão em Python e o prompts.json estão em useapi/google-flow-api/nano-banana-compare. Clone, edite o prompts.json e rode um comando para gerar o conjunto completo da comparação com a sua conta do Google Flow.

Perguntas frequentes

  • Existe uma API do Nano Banana 2.1 ou do Nano Banana Pro? Pela useapi.net, sim: a Google Flow API roda as versões do Google Flow como nano-banana-2 (Nano Banana 2.1), nano-banana-2-lite e nano-banana-pro no POST /images. Na Gemini API oficial, o Nano Banana 2.1 custa cerca de $0,034 por imagem 1K e o Nano Banana Pro $0,134 por imagem, contra nenhuma cobrança por imagem aqui (em novembro de 2026).
  • Qual é a diferença entre o Nano Banana 2 Lite, o 2.1 e o Pro? Pela useapi.net os três rodam no mesmo endpoint, cada um com o seu ponto forte. O nano-banana-pro (Gemini 3 Pro Image) é o mais caprichado e o que segue as instruções mais de perto, o nano-banana-2 (Nano Banana 2.1) dá a leitura mais dinâmica, e o nano-banana-2-lite (Gemini 3.1 Flash-Lite Image), o padrão, levou cerca de metade do tempo do Pro nos nossos testes. Veja Qual modelo usar?
  • Quanto custa a API do Nano Banana? Pela useapi.net, as imagens não consomem créditos do Flow em nenhuma assinatura do Google AI, inclusive numa conta gratuita, e não há chave da Gemini API nem conta de faturamento do Cloud para configurar. Na Gemini API oficial, o Nano Banana 2 Lite custa cerca de $0,034 por imagem 1K (em novembro de 2026). Veja Preços.
  • As imagens passam por moderação? Pela useapi.net, os seus prompts passam pela moderação de conteúdo do próprio Google, e uma requisição rejeitada devolve um resultado vazio. As decisões de moderação variam entre requisições e entre modelos, então tentar de novo, editar o prompt ou trocar de modelo costuma dar certo, porque cada modelo Nano Banana modera de um jeito um pouco diferente.
  • Preciso de captcha ou de um projeto no Google Cloud? Com a useapi.net você não precisa de projeto no Google Cloud nem de resolver captcha por conta própria. O Google Flow pede um reCAPTCHA a cada imagem, e o worker da useapi.net resolve tudo automaticamente: a sua primeira conta do Google Flow vem com 300 resoluções grátis nas nossas próprias chaves da AntiCaptcha, CapSolver e EzCaptcha, e depois disso você adiciona as chaves do seu provedor. O script deste guia não envia captchaToken.

Conclusão

Visite o nosso servidor no Discord ou o canal no Telegram para qualquer dúvida de suporte.

Veja o nosso repositório no GitHub com exemplos de código.

Publicado também em

Também publicado no dev.to (em inglês) e discutido no Reddit (em inglês).

Comece a usar a API

Uma assinatura de US$ 15 por mês dá acesso a todas as APIs da useapi.net: um token, todos os serviços. Você conecta até 3 contas suas por serviço, e a useapi.net cuida da API REST, do balanceamento de carga e do polling. Precisa de mais contas? Cada assinatura extra custa US$ 10 por mês e acrescenta mais 3 contas por serviço.

Assinar — US$ 15/mês Pagar com cripto

Não tem cartão de crédito internacional? Você também pode assinar com criptomoedas (pagamentos em cripto não são reembolsáveis). Preços e planos de volume estão na página de assinatura. Pagando pelo Stripe, você recebe reembolso integral em até 14 dias após a primeira compra, se tiver menos de 50 gerações bem-sucedidas. Já é assinante? Altere a quantidade no portal do cliente Stripe em vez de comprar de novo.