Nano Banana 2 Lite vs 2 vs Pro: Google Flow Image Models Compared

7 min read • July 2, 2026

Table of contents

  1. Introduction
  2. What are the three Nano Banana models?
    1. Upscaling to 2K/4K
  3. Pricing
  4. The comparison prompt
  5. Generate across all three models
  6. Examples
  7. Which Nano Banana model should you use?
  8. Run it yourself
  9. Frequently asked questions
  10. Conclusion

Introduction

Google Flow ships three Nano Banana image models — nano-banana-2-lite, nano-banana-2, and nano-banana-pro — and you can drive all three from one prompt through the useapi.net Google Flow API. You use your own Google Flow account, so there’s no Google Cloud project, no API key, and no per-image metering — image generation is included on any Google AI plan, even a free one, where the official Gemini API bills $0.034–$0.134 per image.

This guide runs the exact same prompt through Lite, 2, and Pro so you can see how they differ, then hands you a runnable Node.js script that generates the whole set in one command. Want a from-scratch how-to first? See the sibling image-generation tutorial.

What are the three Nano Banana models?

Pick a model per request with the model field. If you omit it, Google Flow uses nano-banana-2-lite — its default since July 2026. All three run on any Google AI subscription, including a free account.

Model id Marketing name Best for References (I2I) Speed
nano-banana-2-lite (default) Nano Banana 2 Lite / Gemini 3.1 Flash-Lite Image fast, high-volume generation on any plan max 10 fastest
nano-banana-2 Nano Banana 2 / Gemini 3.1 Flash Image balanced quality and speed max 10 fast
nano-banana-pro Nano Banana Pro / Gemini 3 Pro Image highest fidelity and instruction-following max 10 slower

All three accept the same aspect ratios (16:9, 4:3, 1:1, 3:4, 9:16, plus auto in image-to-image mode), count (1–4), seed for reproducibility, up to 10 reference images, inline @-mentions, and 2K/4K upscaling. The deprecated aliases imagen-4 (Google removed Imagen from Flow in July 2026) and nano-banana are still accepted and map to nano-banana-2-lite and nano-banana-2 respectively. Full per-model detail is on the POST /images reference.

Upscaling to 2K/4K

Any generated image can be upscaled with POST /images/upscale: pass its mediaGenerationId and a resolution of 2k (default) or 4k. The response is base64 in encodedImage. 2k works on any plan; 4k requires a paid Google account.

Pricing

Image generation is included. You keep your normal Google AI account — even a free one works for images (a paid plan is only needed for video and 4k upscales) — plus a flat $15/month to useapi.net for API access to every service. No per-image metering, no per-call surcharge.

Third-party Google Flow API by useapi.net vs. the official Gemini API — drive your own Google Flow subscription instead of metered, per-call API billing:

Model Official Gemini API useapi.net (Flow Pro) useapi.net (Flow Ultra)
Veo 3.1 Fast — 8s clip $0.80 ~$0.40 ~$0.10
Veo 3.1 Quality — 8s clip $3.20 ~$2.00 ~$1.00
Veo 3.1 Lite — 8s clip $0.40 ~$0.20 ~$0.05
Veo 3.1 Lite, lower priority — — $0 (Ultra $199)
Gemini Omni Flash — 8s clip — (Flow only) ~$0.50 ~$0.25
Nano Banana Pro — per image $0.134 included included
Nano Banana 2 — per image $0.067 included included
Nano Banana 2 Lite — per image $0.034 included included

Expected daily output — Ultra ($199/mo) plan. Daily averages observed on top real accounts. These are expected, not guaranteed: Google governs the underlying Flow allowances and they vary with demand.

Free workload (no Flow credits spent) Avg generations / day*
Veo 3.1 Lite — lower priority video ~1,000
Images — Nano Banana 2 Lite, Nano Banana 2, Nano Banana Pro up to ~500

*Averages from the busiest real accounts — not guarantees. They are set by Google’s own allowances and fluctuate with demand. Applies only to the free lower-priority video queue and image generation. Credit-metered models (Veo 3.1 Fast / Quality and Gemini Omni Flash) are not shown here — their volume is bounded by your plan’s monthly Flow credits (see the credit table), not a free allowance.

Veo is billed per second on the Gemini API (an 8-second 720p clip shown) and images are priced per image. Through useapi.net you spend your own Flow plan credits and pay a flat $15/month — image generation is included on any Google AI plan, and there is no Google Cloud project, API key, or per-call metering.

Full plan and credit details are on the Google Flow overview. See the setup guide to connect your account.

The comparison prompt

A model comparison is only useful if the prompt is hard. This one is a deliberately absurd, single-frame scene that stress-tests several things at once: a named photographic style (David LaChapelle), a multi-subject spatial layout (a swarm forming an arrow in the top-left, a forced-perspective bee in the bottom-right), prop fidelity (dripping honeycomb), a specific comedic facial expression (o_O cartoon eyes), and a clashing tone — all in one cohesive image.

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.

Generate across all three models

You need a useapi.net API token and a connected Google Flow account. POST /images is synchronous — one call blocks until the images are ready (typically 20–60 seconds, and the Pro model can take up to ~2 minutes under load) and returns a media[] array with one entry per image, so there’s no jobid to poll.

A single call — swap model to compare:

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

# each image is at .media[N].image.generatedImage.fifeUrl
curl -o pro_1.jpg "$(jq -r '.media[0].image.generatedImage.fifeUrl' result.json)"

To run the full comparison in one command, the Node.js script below reads prompts.json — one entry per model, all with the same prompt — submits each, and downloads every returned image with a model-labeled filename. You need Node.js v21+. Put both files in a folder and run node ./google-flow-nano-banana-compare.mjs API_TOKEN EMAIL, where API_TOKEN is your useapi.net API token and EMAIL is your connected Google Flow account. The script looks the account up by email and checks its health before submitting, and sends no captchaToken — the useapi.net worker solves the reCAPTCHA automatically.

Prefer to clone and run it? The complete script, a Python port, and prompts.json are on GitHub in useapi/google-flow-api.

Expand 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."
    }
]
Expand google-flow-nano-banana-compare.mjs script 
/*

Script version 1.0, July 2, 2026

Batch-compare Google Flow's Nano Banana image models (2 Lite, 2, 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 all parameters see https://useapi.net/docs/api-google-flow-v1/post-google-flow-images

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

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

You need Node.js v21 or newer: https://nodejs.org/

*/

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

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

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

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

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

async function downloadImage(url, filename) {
    try { await fs.access(filename); console.log(`⚠️ ${filename} exists, skipping.`); return; } catch {}
    if (!url) { console.error(`🛑 No fifeUrl for ${filename}`); return; }
    console.log(`✅ Downloading ${filename}`);
    const res = await fetch(url);
    if (!res.ok) { console.error(`⛔ Download failed ${filename} (HTTP ${res.status})`); return; }
    await writeFile(filename, Readable.fromWeb(res.body));
}

async function submitImage(apiToken, email, prompt, index) {
    const model = prompt.model ?? DEFAULT_MODEL;
    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 start = 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 text = await response.text();

        if (response.status === 200) {
            const media = JSON.parse(text)?.media ?? [];
            if (media.length === 0) console.error(`🛑 200 OK but no media (moderated?) for ${model}`);
            for (let i = 0; i < media.length; i++)
                await downloadImage(media[i]?.image?.generatedImage?.fifeUrl, `${model}_${i + 1}.jpg`);
            console.log(`🆗 ${model} done (${elapsedTimeSec(start)} sec)`);
            return 200;
        }
        if (response.status === 429 || response.status === 503) {
            console.log(`🔄️ HTTP ${response.status}, retry in 30s`, text);
            await sleep(SLEEP_RETRY);
            continue;
        }
        console.error(`🛑 ${model} failed HTTP ${response.status}`, text);
        return response.status;
    }
}

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

    const accounts = await fetchAccounts(apiToken);
    if (!accounts[email]) {
        console.error(`⛔ Account ${email} not found. See 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}'.`);
        process.exit(1);
    }

    const prompts = JSON.parse(await fs.readFile(promptFile, 'utf8'));
    console.log(`Comparing ${prompts.length} model runs …`);
    for (let i = 0; i < prompts.length; i++)
        await submitImage(apiToken, email, prompts[i], i + 1);
    console.log('COMPLETED');
}

main();

Examples

Here is the same beekeeper prompt rendered by each model at 9:16, generated through this Google Flow API. The differences are consistent: Pro is the most polished and the most literal about the instructions, 2 is the most dynamic, and Lite is the fastest while staying close.

nano-banana-pro — the most polished and editorial, and the only model that reliably renders the veil netting, the bees crawling on the comb, and the literal o_O cartoon eyes.

Nano Banana Pro beekeeper result via the Google Flow API

nano-banana-2 — the most dynamic and energetic interpretation, with the clearest arrow-shaped swarm and lots of situational detail (work boots, bees on the frame).

Nano Banana 2 beekeeper result via the Google Flow API

nano-banana-2-lite — the fastest of the three (roughly half Pro’s time in our runs) while keeping the composition, the honey drip, and the googly-eyed foreground bee.

Nano Banana 2 Lite beekeeper result via the Google Flow API

Which Nano Banana model should you use?

  • Reach for nano-banana-pro when fidelity matters most — hero shots, complex multi-subject scenes, precise text or instruction-following. It is the slowest of the three.
  • Reach for nano-banana-2 for a strong balance of quality and speed, or when you want a more dynamic, stylized read of a prompt.
  • Reach for nano-banana-2-lite (the default) for iteration and high-volume batches where speed matters and the quality is still very close.

Because they share the same request shape, switching is a one-word change to model — generate a batch across all three and pick the winner, exactly like the script above does.

Run it yourself

The complete Node.js script, a Python port, and prompts.json live in useapi/google-flow-api/nano-banana-compare. Clone it, edit prompts.json, and run one command to generate the full comparison set from your own account.

Frequently asked questions

  • Is there a Nano Banana 2 or Nano Banana Pro API? Yes — two ways. Google offers these models on the official Gemini API, which meters per image on a Google Cloud project. Or use useapi.net’s Google Flow API, which exposes the same models as nano-banana-2, nano-banana-2-lite, and nano-banana-pro on the POST /images endpoint — driving your own Google Flow account with no Cloud project and no per-image metering, on any Google AI plan including the free tier.
  • What is the difference between Nano Banana 2 Lite, 2, and Pro? They are three tiers of Google’s Nano Banana image family. nano-banana-pro (Gemini 3 Pro Image) is the highest-fidelity model, nano-banana-2 (Gemini 3.1 Flash Image) balances quality and speed, and nano-banana-2-lite (Gemini 3.1 Flash-Lite Image) is the fastest and the default. All three accept up to 10 reference images, the auto aspect ratio in image-to-image mode, and 2K/4K upscaling.
  • Which Nano Banana model is best? For maximum quality, nano-banana-pro. For everyday and high-volume work, nano-banana-2-lite is the default and the fastest, with quality very close to the larger models. See Which model should you use? above.
  • Is it free? Image generation works on any Google AI plan, including a free account, plus a flat monthly subscription to useapi.net for API access to every service. The official Gemini API meters per image instead — see Pricing.
  • How much does the Nano Banana API cost? Through useapi.net there is no per-image charge — you keep your own Google AI plan (a free account works for images) and pay a flat $15/month for API access to every service. On the official Gemini API the same models meter per image: roughly $0.034 (2 Lite), $0.067 (2), and $0.134 (Pro) per 1K image — see Pricing.
  • Do generations get moderated? Google applies content moderation, and a rejected request returns an empty result. Moderation decisions vary between requests and between models, so retrying, editing the prompt, or switching models often succeeds — each Nano Banana model moderates a little differently.
  • Do I need a captcha or a Google Cloud project? No Google Cloud project. Generation requires reCAPTCHA, but you don’t solve it — the useapi.net worker does it automatically, and your first Google Flow account comes with 300 free captcha credits (a one-time grant powered by CapSolver). The script here sends no captchaToken and relies on that automatic solving.

Conclusion

Visit our Discord Server or Telegram Channel for any support questions and concerns.

Check our GitHub repo with code examples.

Cross posted

Also published on dev.to and discussed on Reddit.