Como gerar imagens com o Nano Banana 2.1 e o Nano Banana Pro pela Google Flow API

6 min de leitura • 15 de junho 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. Modelos suportados
    1. Upscale para 2K/4K
  3. Preços
  4. Como gerar uma imagem do Nano Banana com curl
  5. Imagens de referência e personagens
  6. Gere em lote com um script
  7. Exemplos
  8. Perguntas frequentes
  9. Conclusão

Introdução

Um único POST síncrono na Google Flow API da useapi.net devolve até quatro imagens do Nano Banana 2.1, do Nano Banana Pro ou do Nano Banana 2 Lite, feitas 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 da Gemini API.

Este guia mostra os modelos disponíveis, a diferença de preço, o fluxo de imagem numa única chamada com curl pronto para copiar e um script em Node.js que gera imagens em lote a partir de uma lista de prompts. Quer ver como os três modelos se saem com o mesmo prompt? Veja a comparação dos modelos Nano Banana. Precisa de vídeo? Veja o tutorial do Veo 3.1, o guia irmão deste.

Modelos suportados

Escolha o modelo em cada requisição com o campo model (padrão nano-banana-2-lite). Os três modelos funcionam em qualquer assinatura do Google AI, inclusive numa conta gratuita.

ID do modelo Nome comercial Referências (I2I) Proporções Observações
nano-banana-2-lite (padrão) Nano Banana 2 Lite / Gemini 3.1 Flash-Lite Image máx. 10 16:9, 4:3, 1:1, 3:4, 9:16, auto† Modelo de imagem padrão do Google Flow desde julho de 2026. No modo imagem para imagem continua em 16:9, a menos que você informe uma proporção
nano-banana-2 Nano Banana 2.1 máx. 10 16:9, 4:3, 1:1, 3:4, 9:16, auto† Usa auto por padrão no modo imagem para imagem
nano-banana-pro Nano Banana Pro / Gemini 3 Pro Image máx. 10 16:9, 4:3, 1:1, 3:4, 9:16, auto† O modelo de imagem de maior qualidade. Usa auto por padrão no modo imagem para imagem

† auto só vale no modo imagem para imagem (com pelo menos um reference_* ou character_*): o backend tira a proporção da primeira imagem de referência. Com várias referências a orientação não é garantida, então informe uma proporção explícita quando todas as imagens precisarem voltar no mesmo formato.

Os três aceitam count (1–4) e seed para reprodutibilidade. Se você omitir model, a API usa nano-banana-2-lite, com ou sem referências. Dois aliases obsoletos continuam aceitos: nano-banana vira nano-banana-2, e imagen-4 vira nano-banana-2-lite (o Google removeu o Imagen do Google Flow em julho de 2026). Os detalhes e os recursos de cada modelo estão na referência do POST /images.

Upscale para 2K/4K

Imagens geradas com qualquer um dos três modelos podem passar por upscale com POST /images/upscale: informe o mediaGenerationId da imagem e um resolution de 2k (padrão) ou 4k. A resposta vem em base64 no encodedImage. O 2k funciona em qualquer plano, inclusive numa conta gratuita. O 4k exige o Google AI Ultra, e em qualquer outro plano responde 400 com 4k upscaling is not available for this account antes de resolver um captcha, então não custa nada e tentar de novo não adianta. Nenhum dos dois consome créditos do Flow.

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. Um plano pago só é necessário para vídeo com Omni 1.1 Flash, vídeo com Omni 1.2 Flash acima de 10 segundos, extensão com Omni 1.2 e upscale de vídeo, e o upscale de imagem em 4k exige o Ultra. O preço de cada modelo em cada plano, comparado com a API oficial, está na tabela de preços do Google Flow.

Como gerar uma imagem do Nano Banana com curl

Você precisa de um token de API da useapi.net e de uma conta do Google Flow conectada. A geração de imagens é síncrona: um único POST espera até as imagens ficarem prontas (normalmente de 10 a 20 segundos) e as devolve na resposta, então não há jobid para consultar. O segundo passo é só salvar o resultado, pela URL assinada ou, quando ela não vier, pela imagem em base64 inline.

  1. Envie o prompt — POST https://api.useapi.net/v1/google-flow/images:
curl -X POST "https://api.useapi.net/v1/google-flow/images" \
  -H "Authorization: Bearer $USEAPI_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Cat dressed like a pirate fencing with a real pirate, pirate looks absolutely terrified, this is happening on a deck of the Disney cruise ship",
    "model": "nano-banana-pro",
    "aspectRatio": "16:9",
    "count": 4,
    "seed": 123456
  }' > response.json

A chamada devolve 200 OK com um jobId e um array media, com um item por imagem (count vai de 1 a 4, padrão 4). A URL de download assinada de cada imagem fica em media[].image.generatedImage.fifeUrl:

{
  "jobId": "j1731859345678i-u12345-email:jo***@gmail.com-bot:google-flow",
  "media": [
    {
      "image": {
        "generatedImage": {
          "seed": 123456,
          "mediaGenerationId": "user:12345-email:6a6f...-image:...",
          "prompt": "Cat dressed like a pirate fencing with a real pirate, pirate looks absolutely terrified, this is happening on a deck of the Disney cruise ship",
          "fifeUrl": "https://flow-content.google/image/...",
          "aspectRatio": "IMAGE_ASPECT_RATIO_LANDSCAPE"
        }
      }
    }
  ]
}
  1. Baixe a imagem pelo fifeUrl (a URL assinada vale por tempo limitado, então baixe logo). De vez em quando o fifeUrl não vem e a imagem chega inline em base64 no encodedImage. Nesse caso, decodifique esse campo:
URL=$(jq -r '.media[0].image.generatedImage.fifeUrl // empty' response.json)
if [ -n "$URL" ]; then
  curl -o image_1.jpg "$URL"
else
  jq -r '.media[0].image.generatedImage.encodedImage' response.json | base64 -d > image_1.jpg
fi

O mediaGenerationId de cada imagem gerada pode ser reutilizado como referência numa requisição posterior. Veja Imagens de referência e personagens abaixo.

Quer um webhook também? Passe um replyUrl no corpo da requisição e a API também envia as atualizações de status do job para essa URL. A chamada em si continua esperando as imagens. O payload é igual à resposta de GET /jobs/jobId, em que uma imagem concluída fica em response.media[].image.generatedImage.fifeUrl.

Imagens de referência e personagens

Para orientar uma imagem com uma foto que você já tem, faça primeiro o upload com POST /assets/email (bytes brutos, um Content-Type de imagem, PNG/JPEG/WebP de até 20 MB). A resposta do upload traz o ID da referência aninhado em mediaGenerationId.mediaGenerationId. É essa string aninhada que você devolve como reference_1 (cada um dos três modelos aceita até 10 referências):

# 1. Faça o upload de uma imagem de referência
curl -X POST "https://api.useapi.net/v1/google-flow/assets/john%40gmail.com" \
  -H "Authorization: Bearer $USEAPI_TOKEN" \
  -H "Content-Type: image/jpeg" \
  --data-binary @reference.jpeg

# Resposta: o ID da referência fica aninhado um nível abaixo:
# {
#   "mediaGenerationId": {
#     "mediaGenerationId": "user:12345-email:6a6f...-image:ff9aa5cc-..."
#   },
#   "width": 1024, "height": 1024, "email": "jo***@gmail.com"
# }

# 2. Gere usando essa referência
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",
    "prompt": "Make this photograph look modern",
    "reference_1": "user:12345-email:6a6f...-image:ff9aa5cc-..."
  }'

Para manter a mesma identidade em muitas imagens, junte 1–2 imagens de referência num personagem reutilizável com POST /characters e depois passe o ID character dele como character_1…character_7. Os personagens se combinam livremente com reference_* e dividem o mesmo limite de referências de cada modelo. Você também pode colocar marcadores @reference_1 / @character_1 direto no prompt para indicar em que ponto cada imagem entra. Cada marcador inline precisa de um parâmetro correspondente no corpo.

Gere em lote com um script

Chegar na imagem certa leva muitas tentativas, e rodar cada uma à mão cansa. O script em Node.js abaixo lê uma lista de prompts do prompts.json, faz o upload das imagens de referência, envia cada requisição e baixa todas as imagens devolvidas. Assim você enfileira um lote e volta depois para escolher as melhores. Como o POST /images é síncrono, o script salva cada resultado assim que a chamada retorna.

Você precisa do Node.js v21 ou mais recente. Coloque o prompts.json e o google-flow-images.mjs na mesma pasta e rode node ./google-flow-images.mjs API_TOKEN EMAIL, em que API_TOKEN é o seu token de API da useapi.net e EMAIL é o e-mail da sua conta do Google Flow conectada. O script encontra a conta pelo e-mail automaticamente e verifica o campo health antes de enviar.

Prefere clonar e rodar localmente? O google-flow-images.mjs e o prompts.json completos estão no GitHub, em useapi/google-flow-api.

Abrir prompts.json 
[
    {
        "prompt": "By default the nano-banana-2-lite model generates 4 image variations at 16:9."
    },
    {
        "model": "nano-banana-pro",
        "aspectRatio": "1:1",
        "count": 2,
        "seed": 123456,
        "prompt": "Nano Banana Pro (Gemini 3 Pro Image), two square variations. For all parameters see https://useapi.net/docs/api-google-flow-v1/post-google-flow-images"
    },
    {
        "model": "nano-banana-2",
        "aspectRatio": "auto",
        "reference_1": "./reference_image.jpeg",
        "prompt": "Image-to-image: pass a local reference file as reference_1 (uploaded automatically). auto aspect ratio derives from the first reference. All three models accept up to 10 references."
    },
    {
        "model": "nano-banana-2-lite",
        "aspectRatio": "9:16",
        "count": 4,
        "prompt": "Nano Banana 2 Lite portrait. Other models (nano-banana-2, nano-banana-pro) are selectable via the model field — see the POST /images docs."
    }
]
Abrir o script google-flow-images.mjs 
/*

Script version 1.2, September 11, 2026

Script to batch-generate images using prompts with the Google Flow API v1 by useapi.net 🚀
Uses the synchronous POST /images endpoint (default model: nano-banana-2-lite) and saves each image from fifeUrl, or from encodedImage when fifeUrl is absent.
For more details visit https://useapi.net/docs/api-google-flow-v1/post-google-flow-images

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-images.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-images.mjs user:1234-abcdefhijklmnopqrstuv [email protected]

This command executes the script using API token user:1234-abcdefhijklmnopqrstuv with [email protected] Google Flow account email.

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

- June 15, 2026: Initial release.
- September 10, 2026: Default model is now nano-banana-2-lite (Google removed Imagen from Flow, and imagen-4 now maps to nano-banana-2-lite). Saves encodedImage when fifeUrl is absent, and accepts .jpg reference images.
- September 11, 2026: A prompt whose reference_* file fails to upload is skipped and logged to google-flow-images_errors.txt instead of being submitted without that reference. 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 ERRORS_FILE = 'google-flow-images_errors.txt';
const DEFAULT_PROMPTS_FILE = 'prompts.json';
const DEFAULT_MODEL = 'nano-banana-2-lite';
const SLEEP_429 = 30 * 1000; // in milliseconds

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

// Google Flow accepts png, jpeg and webp for reference images.
const supportedFileExtensions = ['png', 'jpg', 'jpeg', 'webp'];

// reference_1 .. reference_10 are accepted by POST /images.
const referenceParams = Array.from({ length: 10 }, (_, i) => `reference_${i + 1}`);

// { filename: mediaGenerationId }
const uploadedFiles = {};

// Utility to sleep for given milliseconds
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// 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();
}

const elapsedTimeSec = (start) => (Date.now() - start) / 1000;

// Map a file extension to the Content-Type required by POST /assets
const contentTypeForExt = (ext) => ext === 'png' ? 'image/png' : ext === 'webp' ? 'image/webp' : 'image/jpeg';

async function uploadAsset(apiToken, email, filename) {

    // Check if already uploaded
    if (uploadedFiles.hasOwnProperty(filename))
        return uploadedFiles[filename];

    const startTime = Date.now();

    console.log(`⬆️  Account ${email} uploading file…`, filename);

    const body = new Blob([await fs.readFile(filename)]);

    const fileExt = filename.split('.').pop().toLowerCase();

    const response = await fetch(`${urlUploadAsset}${encodeURIComponent(email)}`, {
        method: 'POST',
        headers: {
            'Accept': 'application/json',
            'Authorization': `Bearer ${apiToken}`,
            'Content-Type': contentTypeForExt(fileExt)
        },
        body
    });

    if (response.ok) {
        const json = await response.json();
        // POST /assets returns the reference id nested as mediaGenerationId.mediaGenerationId
        const mediaGenerationId = json?.mediaGenerationId?.mediaGenerationId;
        console.log(`🆗 mediaGenerationId (${elapsedTimeSec(startTime)} sec)`, mediaGenerationId);
        uploadedFiles[filename] = mediaGenerationId;
    }
    else {
        console.error(`❗ Unable to upload file HTTP ${response.status} (${elapsedTimeSec(startTime)} sec)`, await response.text());
        // Do not attempt to upload failed file again
        uploadedFiles[filename] = undefined;
    }

    return uploadedFiles[filename];
}

// Download a single image from its signed fifeUrl.
async function downloadImage(url, filename) {
    try {
        await fs.access(filename);
        console.log(`⚠️ ${filename} already exists. Skipping download.`);
        return;
    } catch {
        // File does not exist, proceed with downloading
    }

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

    console.log(`✅ Downloading ${url} to ${filename}`);
    try {
        const imageResponse = await fetch(url);
        if (!imageResponse.ok) {
            console.error(`⛔ Unable to download ${filename} (HTTP ${imageResponse.status})`, url);
            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: text } = prompt;

    const useModel = model ?? DEFAULT_MODEL;

    console.log(`🚀 ${useModel} » Prompt #${index} • account ${email} …`);

    // Build the request body, uploading any local reference_* file to a mediaGenerationId first.
    const body = { model: useModel, email, prompt: text };

    for (const key of ['aspectRatio', 'count', 'seed'])
        if (prompt[key] !== undefined) body[key] = prompt[key];

    for (const refKey of referenceParams) {
        const value = prompt[refKey];
        if (value)
            body[refKey] = await uploadAsset(apiToken, email, value);
    }

    // A reference that failed to upload would be left out of the body, and the prompt would still be
    // generated (and charged) without it. Skip the prompt instead. uploadAsset remembers the failed file,
    // so a later prompt using it is skipped too, without another upload attempt.
    const failedUploads = referenceParams.filter(refKey => prompt[refKey] && !body[refKey]);
    for (const refKey of failedUploads) {
        console.error(`🛑 Prompt #${index} skipped: ${refKey} ${prompt[refKey]} failed to upload`);
        await fs.appendFile(ERRORS_FILE, `Upload failed for ${refKey} ${prompt[refKey]},#${index}:${text}\n`);
    }
    if (failedUploads.length)
        return;

    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 json = JSON.parse(responseText);
            const media = json?.media ?? [];

            if (media.length == 0)
                console.error(`🛑 200 OK but no media for prompt #${index}:\n${text}\n`);

            // count > 1 returns multiple images in the media array.
            for (let i = 0; i < media.length; i++) {
                const img = media[i]?.image?.generatedImage;
                const filename = `google-flow_${index}_${i + 1}.jpg`;
                // fifeUrl is normally present. When it is absent the image arrived inline as base64 in encodedImage.
                if (!img?.fifeUrl && img?.encodedImage)
                    await fs.writeFile(filename, Buffer.from(img.encodedImage, 'base64'));
                else
                    await downloadImage(img?.fifeUrl, filename);
            }
            return 200;
        }

        switch (response.status) {
            case 429:
                console.log(`🔄️ Retry on HTTP ${response.status}`, responseText);
                await sleep(SLEEP_429);
                break;
            case 503:
                console.log(`🔄️ Service unavailable, retry on HTTP ${response.status}`, responseText);
                await sleep(SLEEP_429);
                break;
            case 402:
                console.log(`🛑 No subscription / insufficient credits`, responseText);
                await fs.appendFile(ERRORS_FILE, `${response.status},#${index}:${text}\n`);
                process.exit(1);
            case 400:
            case 500:
                console.log(`🛑 Rejected (validation or content moderation)`, responseText);
                await fs.appendFile(ERRORS_FILE, `${response.status},#${index}:${text}\n`);
                return response.status;
            default:
                console.log(`❗ FAILED with HTTP ${response.status}`, responseText);
                await fs.appendFile(ERRORS_FILE, `${response.status},#${index}:${text}\n`);
                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-images.mjs <API_TOKEN> <EMAIL> [PROMPTS_FILE]');
        process.exit(1);
    }

    console.info('Script v1.2');
    console.info('Node version is: ' + process.version);

    const start = new Date();
    try {
        console.info('START EXECUTION', start);
        await execute(apiToken, email, promptFile);
    } catch (error) {
        console.error('⛔ Error during execution:', error.stack || error);
    } finally {
        console.info('COMPLETED', new Date());
        console.info('EXECUTION ELAPSED', diffInMinutesAndSeconds(start, new Date()));
    }
}

async function execute(apiToken, email, promptFile) {
    const accounts = await fetchAccounts(apiToken);

    console.info(`Configured Google Flow API accounts (${Object.keys(accounts).length}):`, Object.keys(accounts).join(', '));

    if (Object.keys(accounts).length <= 0) {
        console.error(`⛔ No configured Google Flow accounts found. Please refer to https://useapi.net/docs/start-here/setup-google-flow`);
        process.exit(1);
    }

    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 promptData = await fs.readFile(promptFile, 'utf8');
    const prompts = JSON.parse(promptData);
    console.log(`Total number of prompts to process`, prompts.length);

    let warnings = [];

    // Parameters accepted by this script for the POST /images endpoint.
    // See https://useapi.net/docs/api-google-flow-v1/post-google-flow-images for every model's full parameter set.
    const supportedParams = ['model', 'prompt', 'aspectRatio', 'count', 'seed', ...referenceParams];

    const invalidKeys = (prompt) => Object.keys(prompt).filter(key => !key.startsWith('__') && !supportedParams.includes(key))

    for (let i = 1; i <= prompts.length; i++) {
        const prompt = prompts[i - 1];
        const { prompt: text } = prompt;

        const validateImage = async (file) => {
            if (file) {
                try {
                    await fs.access(file);
                } catch {
                    warnings.push(`⚠️  Image '${file}' does not exist. Prompt ${i}`);
                }

                const ext = file.split('.').pop().toLowerCase();

                if (!supportedFileExtensions.includes(ext))
                    warnings.push(`⚠️  Image ${file} extension ${ext} not supported. Prompt ${i}`);
            }
        };

        const notSupported = invalidKeys(prompt);
        if (notSupported.length)
            warnings.push(`⚠️  Following params not supported: ${notSupported.join(',')}. Prompt ${i}`);

        if (!text)
            warnings.push(`⚠️  prompt is required. Prompt ${i}`);

        await Promise.all(referenceParams.map(refKey => validateImage(prompt[refKey])));
    }

    if (warnings.length > 0) {
        warnings.forEach(warning => console.warn(warning));
        console.error(`⛔ Execution stopped due to warnings.`);
        process.exit(1);
    }

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

function diffInMinutesAndSeconds(date1, date2) {
    const diffInSeconds = Math.floor((date2 - date1) / 1000);
    return `${Math.floor(diffInSeconds / 60)} minutes ${diffInSeconds % 60} seconds`;
};

main();

Exemplos

Imagens reais geradas por esta mesma Google Flow API com o Nano Banana Pro e o Nano Banana 2 Lite, tiradas direto do nosso blog e da comparação de modelos.

Nano Banana Pro — texto para imagem (fonte): “Cat dressed like a pirate fencing with a real pirate… on a Disney cruise ship.”

Resultado de texto para imagem do Nano Banana Pro

Nano Banana Pro — 5 imagens de referência (fonte): cinco retratos individuais combinados numa única foto de grupo, “K-Pop group victory celebration”.

Foto de grupo do Nano Banana Pro feita com várias referências

Nano Banana 2 Lite, o modelo padrão (fonte): o prompt do apicultor da nossa comparação dos três modelos, gerado em 9:16 pelo mais rápido dos três.

Apicultor gerado com o Nano Banana 2 Lite pela Google Flow API

Perguntas frequentes

  • Existe uma API do Nano Banana 2? Pela useapi.net, sim: na Google Flow API, nano-banana-2 gera imagens com o Nano Banana 2.1, a versão que o Google Flow usa, em qualquer assinatura do Google AI ou numa conta gratuita, sem cobrança por imagem. O Nano Banana 2 (Gemini 3.1 Flash Image) custa $0,067 por imagem 1K na Gemini API oficial do Google (em novembro de 2026). É um endpoint REST comum, sem projeto no Cloud.
  • Existe uma API do Nano Banana Pro? Pela useapi.net, sim: o Nano Banana Pro (Gemini 3 Pro Image) roda como nano-banana-pro no endpoint POST /images, e uma única requisição síncrona devolve até quatro imagens, sem cobrança por imagem. A Gemini API oficial do Google cobra $0,134 por imagem Pro (em novembro de 2026).
  • Qual modelo a API usa por padrão? Na useapi.net, o padrão é nano-banana-2-lite (Gemini 3.1 Flash-Lite Image), com ou sem referências. Troque em cada requisição definindo model como nano-banana-2 (Nano Banana 2.1) ou nano-banana-pro (Gemini 3 Pro Image, a maior qualidade). Os três aceitam até 10 imagens de referência e podem passar por upscale para 2K/4K. Nano Banana 2 Lite vs 2.1 vs Pro mostra os três com o mesmo prompt.
  • O Imagen 4 ainda está disponível no Google Flow? Na useapi.net, o ID de modelo imagen-4 continua funcionando, então o código que você já tem segue rodando. Mas o Google removeu o Imagen do Google Flow em julho de 2026, e essas requisições agora geram imagens com o nano-banana-2-lite, o modelo de imagem padrão do Google Flow desde então. Para escolher outro modelo, defina model como nano-banana-2 ou nano-banana-pro.
  • 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 com POST /accounts/captcha-providers. 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 compartilhado no Bluesky.

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.