Nano Banana 2 Lite: Price, Limits and API Code (2026)

Nano Banana 2 Lite is Google’s cheapest Gemini image model, built for one job: turning a prompt, or a prompt plus some reference images, into a usable 1K image quickly and for very little money. Its official name is Gemini 3.1 Flash-Lite Image. In Google’s lineup it sits below Nano Banana 2 and Nano Banana Pro. This post explains what it does, what it costs per image, how it compares with the rest of the family, and how to call it from code without signing up for Google Cloud.

What is Nano Banana 2 Lite?

“Nano Banana” is the nickname that stuck to Google’s Gemini image models. The original Nano Banana (officially Gemini 2.5 Flash Image) arrived in August 2025. Nano Banana Pro followed in November 2025 as the high-fidelity option, and Nano Banana 2 replaced the original as the mainline model in February 2026. Nano Banana 2 Lite came out on July 1, 2026, as the speed and cost tier of that second generation.

In plain terms it is a text-to-image model (you describe a picture in words and it draws it) that can also edit. Editing here means you hand it one or more existing images, called reference images, and tell it what to change or combine. Here is what the model accepts on Unicorn API:

• prompt: the text description or edit instruction.
• ref_images: up to 10 reference images for edits, product placement, style matching or keeping a character consistent.
• aspect_ratio: 16:9, 1:1, 9:16, 21:9, 4:3, 3:2 or 2:3.
• n: how many images to return from one request.

Notice what is missing: there is no resolution setting. Nano Banana 2 Lite renders at 1K only (roughly 1024 pixels on the long side for a square image). That is enough for social posts, thumbnails, ad tests, chat app avatars and product mockups. It is not enough for print, large hero banners or anything a client will crop heavily.

Who it is for

The model makes sense whenever you need many images and each one only has to be good, not perfect. Typical uses:

• Testing prompts before you spend more on a final render with a bigger model.
• Generating 10 to 50 variants of an ad creative to find the two worth keeping.
• Batch product edits: same product, new backgrounds, new seasons.
• Social content and blog illustrations at feed size.
• Features inside your own app where users generate images and you pay per request.

Can you run it locally?

No. Google has not released weights for any Nano Banana model, so there is nothing to download. Every version, including Nano Banana 2 Lite, runs on Google’s servers and you reach it through an API. If self-hosting is a hard requirement, you need an open-weight family such as Flux instead.

Nano Banana 2 Lite vs Nano Banana 2, Pro and 2.1

The most common question is whether Lite is good enough or whether you should pay for a bigger sibling. The table below uses the specs and prices on Unicorn API, where one plan credit costs $0.01.

Model	Released	Resolutions	Reference images	Price per image (credits)
Nano Banana 2 Lite	Jul 2026	1K only	Up to 10	4
Nano Banana 2	Feb 2026	1K, 2K, 4K	Up to 14	8 / 12 / 18
Nano Banana 2.1	Oct 2026	1K, 2K, 4K	Via image_input	4 / 6 / 9
Nano Banana Pro	Nov 2025	1K, 2K, 4K	Up to 8	18 / 18 / 24
Nano Banana (original)	Aug 2025	Default size	Up to 3	4

Which is better, Nano Banana 2 or Nano Banana 2 Lite?

Nano Banana 2 is the stronger model. Google describes it as having strong realism, text and edits, and it goes up to 4K with 14 reference images. Nano Banana 2 Lite gives up the higher resolutions and four reference slots in exchange for speed and half the price at 1K. If you are judging a single hero image, Nano Banana 2 wins. If you are judging cost per usable image across a batch of 200, Lite often wins.

A practical rule: draft in Lite, finish in Nano Banana 2. Both models take the same prompt style, the same aspect ratios and the same ref_images field, so moving a prompt from one to the other is a one-word change in your request.

Nano Banana Pro vs Nano Banana 2

Nano Banana Pro is the high-fidelity, text-accurate model. Reach for it when the image contains a lot of readable text (posters, menus, packaging, infographics) or when fine detail matters more than budget. It costs more than double Nano Banana 2 at 1K, supports fewer aspect ratios (no 3:2 or 2:3) and takes up to 8 reference images. For most realistic photos, Nano Banana 2 is the better value.

What about Nano Banana 2.1?

Nano Banana 2.1, released in October 2026, costs 4 credits at 1K, exactly the same as Lite, and also offers 2K and 4K. Its request shape is different: it takes images through an image_input field rather than ref_images, and it has no n field, so each request returns one image. If you need occasional 2K or 4K output, 2.1 is worth testing next to Lite on your own prompts. If you rely on many reference images or want several outputs per call, Nano Banana 2 Lite is the simpler fit.

How much does Nano Banana 2 Lite cost?

On Unicorn API, Nano Banana 2 Lite costs a flat 4 credits per output image. There is no resolution tier to think about, because there is only one resolution. If you set n, the price is multiplied by it, so n: 4 costs 16 credits.

What a credit is worth depends on how you buy it:

• Monthly plans: $0.01 per credit. Starter is $25, Creator $50, Studio $100, Pro $200 per month.
• Top-ups: $0.015 per credit, and they never expire.

Scenario	Credits	Cost on a plan	Cost with top-ups
1 Lite image	4	$0.04	$0.06
100 Lite images	400	$4.00	$6.00
1,000 Lite images	4,000	$40.00	$60.00
100 Nano Banana 2 images at 1K	800	$8.00	$12.00
100 Nano Banana Pro images at 1K	1,800	$18.00	$27.00

Put another way, the $25 Starter plan’s 2,500 credits buy 625 Nano Banana 2 Lite images, or 312 Nano Banana 2 images at 1K. Full plan details are on the pricing page.

Because one credit balance covers every model, you are not locked in. You can run Lite for drafts, Nano Banana 2 for finals and GPT Image 1.5 when you need a transparent background, all billed the same way. If you want the exact cost before a request runs, call POST /v1/models/price; the request shape is in the API documentation.

How to use Nano Banana 2 Lite through an API

Image generation on Unicorn API is asynchronous. You create a job, then check on it until it finishes. That avoids long-held HTTP connections and lets you fire off many jobs in parallel. The flow is:

1. Create an API key on the keys page and export it as UNICORN_API_KEY.
2. Send POST /v1/jobs with the model id nano-banana-2-lite and an input object.
3. Read the job id from the response.
4. Poll GET /v1/jobs/{id} until status is "succeeded".
5. Download the image from outputs[0].url (or loop over outputs if you set n).

The minimal request with curl

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nano-banana-2-lite",
    "input": {
      "prompt": "A red fox resting in a snowy forest at dawn, soft light, highly detailed"
    }
  }'

# Then check the job using the id from the response:
curl https://api.unicornapi.net/v1/jobs/JOB_ID \
  -H "Authorization: Bearer $UNICORN_API_KEY"

A complete Python example: four ad variants

This script asks Nano Banana 2 Lite for four 9:16 variants of a story ad in one request, waits for the job and saves each image. It uses only the requests library.

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {
    "Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}",
    "Content-Type": "application/json",
}

def create_job(body):
    r = requests.post(f"{API}/v1/jobs", headers=HEADERS, json=body, timeout=30)
    r.raise_for_status()
    return r.json()["id"]

def wait_for_job(job_id, interval=2, timeout=180):
    deadline = time.time() + timeout
    while time.time() < deadline:
        r = requests.get(f"{API}/v1/jobs/{job_id}", headers=HEADERS, timeout=30)
        r.raise_for_status()
        job = r.json()
        if job["status"] == "succeeded":
            return job
        if job["status"] == "failed":
            raise RuntimeError(f"Job {job_id} failed: {job}")
        time.sleep(interval)
    raise TimeoutError(f"Job {job_id} did not finish in {timeout}s")

body = {
    "model": "nano-banana-2-lite",
    "input": {
        "prompt": (
            "Vertical story ad for a cold brew coffee can on a sunlit kitchen "
            "counter, condensation on the can, morning light, empty space at "
            "the top for a headline, photorealistic"
        ),
        "aspect_ratio": "9:16",
        "n": 4,  # 4 images x 4 credits = 16 credits
    },
}

job = wait_for_job(create_job(body))

for i, output in enumerate(job["outputs"]):
    img = requests.get(output["url"], timeout=60)
    img.raise_for_status()
    with open(f"ad_variant_{i + 1}.png", "wb") as f:
        f.write(img.content)
    print("Saved", f"ad_variant_{i + 1}.png")

To move the winning prompt up to a 2K final, change the model to nano-banana-2 and add "resolution": "2K" to the input. Nothing else changes. If you would rather click than code first, the same models are in the browser playground, and if you work inside Cursor or Claude Code you can call them as tools through MCP.

Editing images with Nano Banana 2 Lite and reference images

Editing is where Nano Banana 2 Lite earns its keep for e-commerce and marketing work. You pass existing images in ref_images and describe the change in the prompt. With up to 10 references you can combine a product shot, a background, a style sample and a model photo in one request.

body = {
    "model": "nano-banana-2-lite",
    "input": {
        "prompt": (
            "Place the sneaker from image 1 on the wet city pavement from "
            "image 2 at night, keep the sneaker's exact colours and logo, "
            "match the moody colour grade of image 3"
        ),
        "ref_images": [
            "https://example.com/sneaker.png",
            "https://example.com/pavement.jpg",
            "https://example.com/style.jpg",
        ],
        "aspect_ratio": "4:3",
    },
}
job = wait_for_job(create_job(body))
print(job["outputs"][0]["url"])

The reference images must be reachable by public URL (or a signed URL that stays valid while the job runs). A few habits make edits far more reliable:

• Refer to images by position. “The sneaker from image 1” is clearer to the model than “the shoe”.
• Say what must not change. Logos, colours, faces and product proportions drift unless you ask the model to keep them.
• Use fewer, better references. Ten slots does not mean you should fill them. Two or three clean images usually beat ten noisy ones.
• Edit in small steps. One change per request is easier to control than five changes at once, and at 4 credits a step it stays cheap.

If your edit work is mostly single-image retouching with exact pixel control, Flux 3 Klein Edit Image is another low-cost option worth comparing. For more prompt ideas you can adapt to Lite, see these Nano Banana prompt examples.

Common mistakes with Nano Banana 2 Lite

Most disappointing results come from a handful of avoidable errors.

Sending a resolution field

Nano Banana 2 Lite has no resolution or output_format input. Copying a request from Nano Banana 2 and leaving those fields in will not give you a 4K image. If you need bigger output, generate at 1K and upscale, or switch models.

Forgetting that n multiplies the price

Setting n to 8 inside a loop of 100 prompts means 800 images and 3,200 credits, not 400. Do the arithmetic before a batch run, or check the exact price first with the pricing endpoint.

Expecting Pro-level text

Lite can place short words and headlines, but dense text such as menus, labels with ingredients or multi-line posters is where Nano Banana Pro is built to be accurate. A common workflow is to leave space in a Lite image and add text in your design tool, which also makes copy changes free.

Judging it on a single image

Any model will produce a weak image sometimes. The point of a cheap model is to generate several candidates and pick one. Compare Lite and Nano Banana 2 on the same 20 prompts at the same aspect ratio, then count how many results you would actually ship from each and divide by cost.

Polling too fast or with no timeout

Polling every 100 milliseconds wastes requests, and polling with no deadline leaves a stuck script running forever. A two-second interval with a timeout and an explicit check for "failed", as in the code above, is a sensible default.

When to choose a different model

Nano Banana 2 Lite is a strong default for volume work, but it is not the answer to every brief. A quick decision guide:

• You need 2K or 4K: Nano Banana 2.1 if price matters most, Nano Banana 2 for its stronger realism and 14 reference images.
• The image is mostly text: Nano Banana Pro.
• You need a transparent background: GPT Image 1.5, which has a background option.
• You want the lowest price per image: Flux 3 Klein Text to Image at 1.6 credits per 1K image (rounded up to whole credits per request).
• You want fast, cheap 1K images with heavy reference use: stay on Nano Banana 2 Lite.

Because every one of these runs on the same key and the same job endpoint, switching is a change to the model string and a couple of input fields. Many teams route automatically: Lite for previews inside their app, a bigger model only when a user clicks “final”. The full list of options is in the model catalog.

Start small. Generate a dozen images with Nano Banana 2 Lite on your real prompts, run the same set through Nano Banana 2, and let the results, not the spec sheet, decide which one goes into production.