Google Nano Banana Pricing: Cost per Image (2026)

Nano Banana pricing depends on two things: which of Google’s Nano Banana models you call, and, for Nano Banana Pro, which resolution you ask for. If you only need the short version, the original model and the newer Lite model are cheap enough for drafts and bulk work, while Pro costs a few times more per image and buys you sharper detail, accurate text in the image, and 4K output. This post gives exact per-image costs, shows how to turn them into a monthly budget, and includes working code so you can check what a request will cost before you run it.

How Nano Banana pricing works

“Nano Banana” is the nickname for Google’s Gemini image models. The name started with one model and now covers a family. Three of them are available through Unicorn API:

• Nano Banana: the original Gemini image model. Quick, natural-looking images and edits, with up to 3 reference images (pictures you upload so the model can match a product, face or style).
• Nano Banana Pro: high-fidelity images with accurate text rendering at 1K, 2K or 4K, with up to 8 reference images.
• Nano Banana 2 Lite: the cheapest Gemini image model, built for fast 1K images and edits, with up to 10 reference images.

Google bills its own API by tokens. A token is a small unit of data the model reads or writes. An image counts as a block of output tokens, and bigger resolutions use more of them. Your prompt text and any reference images count as input tokens on top of that. The model is accurate, but it makes the true cost of a single image awkward to work out, which explains why so many forum threads simply ask “how much per image?”

Unicorn API turns that into a flat price per image, counted in credits. You get credits two ways:

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

So a model priced at 4 credits costs $0.04 per image on a plan and $0.06 with top-up credits. The full plan details are on the pricing page. One rule matters for budgeting: the price is per output image. If you set the input field n to generate several images in one request, the price is multiplied by n.

Nano Banana pricing per image: every model compared

Here is Nano Banana pricing for each model and setting, plus two non-Google models that people often compare them with. Dollar figures follow directly from the credit prices above.

Model	Setting	Credits per image	On a plan ($0.01/credit)	Top-up ($0.015/credit)
Nano Banana	Default	4	$0.04	$0.06
Nano Banana 2 Lite	Default (1K)	4	$0.04	$0.06
Nano Banana Pro	1K	18	$0.18	$0.27
Nano Banana Pro	2K	18	$0.18	$0.27
Nano Banana Pro	4K	24	$0.24	$0.36
GPT Image 1.5	Low / medium / high	3 / 4 / 22	$0.03 / $0.04 / $0.22	$0.045 / $0.06 / $0.33
Flux 3 Klein Text to Image	1K / 2K / 4K	1.6 / 2.5 / 6.5	see note	see note

A note on the Flux row: prices are rounded up to whole credits per request, after multiplying by the number of images. A single 1K image from Flux 3 Klein Text to Image therefore costs 2 credits, but ten of them in one request cost 16, not 20. The Nano Banana models are already priced in whole credits, so rounding never changes their cost.

Three things stand out in this table:

1. Nano Banana and Nano Banana 2 Lite cost the same. Choose between them on capability, not price. Lite takes more reference images and supports two extra aspect ratios (3:2 and 2:3).
2. Nano Banana Pro at 1K and 2K is the same price. There is rarely a reason to ask for 1K.
3. Pro costs about 4.5x the lighter models at 2K, and 6x at 4K. That gap is the whole budgeting decision.

Which Nano Banana model should you pay for?

Price only matters relative to what you get, so here is how the three models split in practice.

Nano Banana Pro: when the image is the final product

Pay for Pro when the output goes straight in front of customers: product shots, ad creatives, posters, packaging mock-ups, anything with words in it. Text rendering is the big one. Older image models garble lettering, and a misspelled headline makes an image useless no matter how cheap it was. Pro also takes up to 8 reference images, which helps when you need a product or character to stay consistent across a set. If you need print-sized output, it is the only Nano Banana model here with a 4K option.

Nano Banana: quick, natural edits

The original model is good at natural-looking images and conversational edits like “make the background a beach” or “change the jacket to red”. At 4 credits it is cheap enough to iterate freely. Its limit is 3 reference images, which is fine for most single-subject edits.

Nano Banana 2 Lite: volume and reference-heavy edits

People searching “nano banana 2.0” or “how much is Nano Banana 2 per image” usually want the newest model at the lowest price. Nano Banana 2 Lite is the answer on cost: 4 credits per image, the same as the original, with up to 10 reference images and output at 1K. It suits thumbnails, social posts, catalog variations and drafts. For more on the Nano Banana 2 family itself, see our post on the Nano Banana 2 AI image generator.

When a non-Google model is cheaper for the job

If you are price-shopping, two alternatives belong in the comparison. GPT Image 1.5 at low quality costs 3 credits, a little below the Nano Banana floor, and it offers transparent backgrounds, which none of the Nano Banana models list. At high quality it costs 22 credits, more than Nano Banana Pro at 2K. Flux 3 Klein is the cheapest option in the table for high-volume work, and Flux 3 Klein Edit Image covers edits from a source image. Because every model sits behind the same API key, switching models is a one-word change in your request.

A worked example: budgeting a month of images

Abstract per-image Nano Banana pricing becomes useful when you map it to a real workload. Take a small online store that needs new imagery every month:

• 400 draft images to explore concepts, backgrounds and layouts
• 100 final product images, some with text overlays, at 2K
• 10 hero banners at 4K for the homepage and print

Option A: everything on Nano Banana Pro

• 400 drafts at 2K × 18 credits = 7,200 credits
• 100 finals at 2K × 18 credits = 1,800 credits
• 10 banners at 4K × 24 credits = 240 credits
• Total: 9,240 credits, or $92.40 at plan rates

Option B: draft cheap, finish on Pro

• 400 drafts on Nano Banana 2 Lite × 4 credits = 1,600 credits
• 100 finals on Pro at 2K × 18 credits = 1,800 credits
• 10 banners on Pro at 4K × 24 credits = 240 credits
• Total: 3,640 credits, or $36.40 at plan rates

Option B gives the same final quality for about 40% of the cost. The drafts were never going to be published, so paying Pro prices for them bought nothing.

Choosing a plan for that volume

At 3,640 credits a month, the Creator plan ($50 for 5,000 credits) covers the workload with room for retries. Starter ($25 for 2,500 credits) plus 1,140 top-up credits would cost $25 + $17.10 = $42.10, which is cheaper on paper, but leaves no margin. A sensible pattern is to pick the plan that covers your typical month and keep a small stock of top-up credits for busy months, since top-ups never expire.

Budget for retries too. Few prompts land on the first try. If you expect two or three attempts per final image, multiply the final-image line accordingly, or better, do the retrying on the cheap model and only send the winning prompt to Pro.

Generating Nano Banana Pro images through the API

Media models on Unicorn API run as jobs: you submit a request to POST /v1/jobs, get back a job ID, then poll GET /v1/jobs/{id} until the status is succeeded and read the image URL from outputs[0].url. Create a key on the API keys page and export it as UNICORN_API_KEY.

Python: one 2K Nano Banana Pro image

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {"Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}"}

# 18 credits: Nano Banana Pro costs the same at 1K and 2K
resp = requests.post(
    f"{API}/v1/jobs",
    headers=HEADERS,
    json={
        "model": "nano-banana-pro",
        "input": {
            "prompt": "Studio photo of a ceramic coffee mug on a walnut table, "
                      "the mug reads 'MONDAY FUEL' in bold serif letters, soft window light",
            "resolution": "2K",
            "aspect_ratio": "1:1",
        },
    },
)
resp.raise_for_status()
job = resp.json()

while True:
    job = requests.get(f"{API}/v1/jobs/{job['id']}", headers=HEADERS).json()
    if job["status"] == "succeeded":
        break
    if job["status"] == "failed":
        raise RuntimeError(f"Job failed: {job}")
    time.sleep(3)

print(job["outputs"][0]["url"])

curl: four cheap drafts on Nano Banana 2 Lite

This request asks for four images with n, so it costs 4 × 4 = 16 credits.

curl 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": "Ceramic coffee mug on a walnut table, soft window light, product photo",
      "aspect_ratio": "3:2",
      "n": 4
    }
  }'

# Then poll with the returned id:
curl https://api.unicornapi.net/v1/jobs/JOB_ID \
  -H "Authorization: Bearer $UNICORN_API_KEY"

Estimating cost before you run

For a firm number, Unicorn API exposes POST /v1/models/price, which returns the exact price of a request before you submit it. The request format is in the API documentation. For quick budgeting in your own code, a local estimator built from the price table works well and shows how n and rounding interact:

import math

# Credits per image, from the published price list
PRICES = {
    "nano-banana": {"default": 4},
    "nano-banana-2-lite": {"default": 4},
    "nano-banana-pro": {"1K": 18, "2K": 18, "4K": 24, "default": 18},
    "flux-3-klein-text-to-image": {"1K": 1.6, "2K": 2.5, "4K": 6.5, "default": 1.6},
}

def estimate_credits(model, resolution=None, n=1):
    table = PRICES[model]
    per_image = table.get(resolution, table["default"])
    # Price is per output, multiplied by n, rounded up to whole credits
    return math.ceil(per_image * n)

print(estimate_credits("nano-banana-pro", "4K", n=10))          # 240
print(estimate_credits("nano-banana-2-lite", n=400))            # 1600
print(estimate_credits("flux-3-klein-text-to-image", "1K", 1))  # 2

Treat the local table as a convenience and the price endpoint as the source of truth, since prices can change. If you would rather test prompts by hand first, every model here is also available in the browser image studio. For a deeper walkthrough of reference images and edits, see our Nano Banana API guide.

Free access, Google’s own billing and third-party plans

Search results for Nano Banana pricing mix three very different things, and it helps to separate them.

Free use in Google’s apps

Google’s consumer apps let you make some Nano Banana images for free, with daily limits that Google adjusts over time, and paid consumer subscriptions raise those limits. This is fine for personal experiments. It does not give you an API, so you cannot plug it into a product, a script or a batch pipeline. If your question is “is the Nano Banana API free?”, the practical answer is no: programmatic image generation is billed everywhere.

Google’s API billing

Going direct to Google means token-based billing. Output image tokens make up most of the cost, the number of tokens depends on resolution, and prompt text and reference images add input charges. Google also offers a batch mode at a discount for jobs that can wait. If your stack is already built on Google Cloud, that route is reasonable. The trade-off is that your Gemini image costs sit on one bill, and any other image, video, audio or chat models you use sit on other bills with other units.

Third-party subscription sites

Several sites sell “Nano Banana Pro plans” with monthly or annual fees and their own credit systems. Before you pay, check three things:

• What one credit buys. A plan that sounds cheap per month can be expensive per image. Divide the monthly fee by the number of Pro images it actually allows at the resolution you need.
• Whether you get an API. Many are web apps only.
• What happens to unused credits. Find out if they roll over or vanish at renewal.

Unicorn API takes a different approach: one key and one bill across image, video, audio and chat models, flat per-image credit prices, and a price endpoint that tells you the cost up front. Browse the full model catalog to see what else your credits cover.

Mistakes that inflate your image bill

Most overspending on Nano Banana pricing comes from a handful of habits that are easy to fix.

1. Running Pro for every draft. As the worked example showed, sending exploratory prompts to Pro can more than double your bill. Draft on Nano Banana or Nano Banana 2 Lite at 4 credits, then re-run the winners on Pro.
2. Asking for 1K on Pro. Pro costs 18 credits at both 1K and 2K. Requesting 1K gets you fewer pixels for the same money.
3. Defaulting to 4K. 4K costs 24 credits against 18 at 2K, a third more per image. Most web and social placements display well below 4K. Save it for print, large banners or images you plan to crop heavily.
4. Forgetting that n multiplies the price. A request with n set to 4 on Pro at 4K costs 96 credits, not 24. Check the multiplier when you batch.
5. Ignoring retries in the budget. If a final image takes three attempts, it costs three times the list price. Fix prompts on a cheap model first.
6. Mixing up the model names. “Nano Banana”, “Nano Banana Pro” and “Nano Banana 2 Lite” are different models at different prices. A config file that says nano-banana-pro where you meant nano-banana costs 4.5x as much per image.
7. Comparing token prices with per-image prices directly. A per-token rate leaves out input charges for prompts and reference images. Compare on cost per finished image at the resolution you actually use.
8. Paying top-up rates for steady usage. Top-up credits cost 50% more than plan credits. If you spend a predictable amount each month, a plan is cheaper. Keep top-ups for spikes.

Is Nano Banana Pro worth the extra cost?

For finished, customer-facing images, usually yes. The difference between 4 and 18 credits is $0.14 per image on a plan, which is small next to the cost of a designer fixing garbled text or a reshoot. For anything that is not the final output, usually no: drafts, mood boards, A/B variations and internal mock-ups are better served by the 4-credit models.

The simplest rule: use Nano Banana pricing tiers as a pipeline, not a choice. Start on Nano Banana 2 Lite or the original Nano Banana to find the prompt, then send only the images you will publish to Nano Banana Pro at 2K, and reach for 4K only when the placement needs it. If you work inside an AI coding tool, you can also call these models from Cursor or Claude Code through the agent integration, which makes it easy to script the whole draft-then-finish flow.