Nano Banana API overview: models and pricing

​

Compare the models

• This site labels the original model, gemini-2.5-flash-image, as Standard so it isn’t confused with the family name. Its shutdown date and migration are covered on this page.
• Every model accepts OpenAI-compatible and Gemini-native requests; only Gemini-native requests can set the aspect ratio and output size. See Choose a protocol.
• Prices are LaoZhang API public pricing as of October 7, 2026; see Models and pricing for the current list.
• Single 2K, 16:9 requests with the same prompt on October 14, 2026 took 25 s on Nano Banana 2.1, 21 s on Nano Banana 2, and 69 s on Nano Banana Pro; see the side-by-side samples in the Nano Banana 2.1 guide.
• The table after this list gives the 10 aspect ratios and the four that Nano Banana 2.1 and Nano Banana 2 add.
• On the OpenAI-compatible route there is no ratio or size setting. From a text-only prompt, Standard returns 1024×1024 images, Nano Banana 2.1 returns a 1K image in a frame the model picks, and the other models return 1:1 images at 1K.
• A dash (—) means Google doesn’t list the feature for Standard. Capabilities come from Google’s Nano Banana image generation guide.

• No platform concurrency limit and no throttling; a 429 comes from upstream capacity, see Concurrency and 429.
• Each model has one fixed per-call price. What is charged when a request fails or returns no image is in Billing, and Billing and failure rules compares the three image families.

​

Choose a protocol

OpenAI-compatible:  POST https://api.laozhang.ai/v1/chat/completions
Gemini-native:      POST https://api.laozhang.ai/v1beta/models/{model}:generateContent

• aspectRatio takes a value from the model’s list.
• imageSize takes a size with the K in uppercase; some models reject lowercase sizes such as 2k. The values each model accepts are in the table below.

​

Billing

• HTTP 200 with no image: charged as one call. An HTTP 200 from upstream counts as a completed call, for generation and editing alike. LaoZhang API doesn’t review prompts or outputs, so it doesn’t bill by whether an image came back. See Avoid paying for empty responses.
• Client timeout: the server may still finish the image and charge for it. Check call logs before you retry so you don’t pay twice.
• Non-200 upstream response: a 400, 429, 503, or similar response that never reached generation is not charged.
• Google Search grounding: $0.014 per search on top of the per-call price. This matches Google’s $14 per 1,000 searches and applies to Nano Banana 2.1, Nano Banana 2, and Nano Banana Pro.
  • The model decides how many searches to run, and the count can vary for the same prompt. Call logs show the number of searches and their charge for each request.
  • For example, a Nano Banana 2.1 request that runs 2 searches costs $0.045 + 2 × $0.014 = $0.073.

​

Avoid paying for empty responses

• The prompt never asks for an image. If it only describes what you want, without saying “generate an image” or “return the edited image”, the model may reason about it and reply with text or nothing.
• Upstream safety filters block the content. When the prompt or a reference image involves copyrighted characters, sensitive people, or sensitive content, Google returns no image and no error code. Resending the same content is usually blocked again, and each attempt is charged.

• sexual, violent, gory, or hateful content, including suggestive borderline content
• removing a watermark from an image
• well-known copyrighted characters, such as Disney, Marvel, or Nintendo characters
• inappropriate content involving minors
• public figures such as celebrities and politicians
• editing financial details such as order screenshots, receipts, or price tags
• changing a real person’s clothes or swapping faces

1. Ask for an image explicitly in every prompt.
2. Screen prompts and reference images yourself before sending them, and remove content likely to trip safety filters.
3. Treat a response with no candidates, or with no inlineData part, as “no image”. When candidates is present, read finishReason and any returned text to see why.
4. Don’t retry an empty response automatically. Change the prompt or references first. Keep backoff retries for 429 and 5xx errors.

​

Set up

1

Create an API key

In Token management, open the create-token dialog (创建令牌), set Billing mode (计费模式) to Usage first (按量优先, recommended) or Per-call (按次计费), and click Create (创建). The default group includes all five Nano Banana models.

2

Store the key in an environment variable

export LAOZHANG_API_KEY="sk-..."  # replace with your LaoZhang API key

3

Install the dependencies

python -m pip install openai requests

The cURL examples also need jq, for example brew install jq or sudo apt-get install jq.

​

Python helper

"""Shared helpers for Nano Banana image models on LaoZhang API."""
import base64
import json
import os
import re
import sys
from pathlib import Path

import requests
from openai import OpenAI

BASE_URL = "https://api.laozhang.ai"
INPUT_TYPES = {".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp"}
DATA_URL = re.compile(r"data:image/[\w.+-]+;base64,([A-Za-z0-9+/=]+)")


def openai_client():
    """OpenAI-compatible client; the SDK sends the key as Authorization: Bearer."""
    # max_retries=0: an automatic retry after a timeout could generate and bill the image twice
    return OpenAI(api_key=os.environ["LAOZHANG_API_KEY"], base_url=f"{BASE_URL}/v1", timeout=300, max_retries=0)


def generate_content(model, parts, image_config=None):
    """Send a Gemini-native generateContent request and return the JSON response."""
    generation_config = {"responseModalities": ["IMAGE"]}
    if image_config:
        generation_config["imageConfig"] = image_config
    response = requests.post(
        f"{BASE_URL}/v1beta/models/{model}:generateContent",
        headers={"Authorization": f"Bearer {os.environ['LAOZHANG_API_KEY']}"},
        json={"contents": [{"role": "user", "parts": parts}], "generationConfig": generation_config},
        timeout=300,
    )
    if response.status_code != 200:
        raise RuntimeError(f"HTTP {response.status_code}: {response.text[:500]}")
    return response.json()


def _extension(raw):
    if raw.startswith(b"\x89PNG"):
        return "png"
    if raw.startswith(b"\xff\xd8\xff"):
        return "jpg"
    if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP":
        return "webp"
    return "bin"


def _write(encoded, stem, number):
    encoded = "".join(encoded.split())
    raw = base64.b64decode(encoded + "=" * (-len(encoded) % 4))  # tolerate missing padding
    suffix = "" if number == 1 else f"-{number}"
    path = Path(f"{stem}{suffix}.{_extension(raw)}")
    path.write_bytes(raw)
    return str(path)


def save_chat_images(content, stem):
    """OpenAI-compatible: save each Base64 data URL found in message.content."""
    found = DATA_URL.findall(content or "")
    if not found:
        raise RuntimeError(f"No image in message.content: {(content or '')[:300]!r}")
    return [_write(data, stem, number) for number, data in enumerate(found, start=1)]


def save_native_images(result, stem):
    """Gemini-native: save each inlineData image in candidates[].content.parts[]."""
    blobs = []
    for candidate in result.get("candidates") or []:
        for part in (candidate.get("content") or {}).get("parts") or []:
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and not part.get("thought"):
                blobs.append(blob)
    if not blobs:
        reasons = [candidate.get("finishReason") for candidate in result.get("candidates") or []]
        raise RuntimeError(f"No image returned: {result.get('promptFeedback') or reasons}")
    return [_write(blob["data"], stem, number) for number, blob in enumerate(blobs, start=1)]


def _encode(path):
    mime = INPUT_TYPES.get(Path(path).suffix.lower())
    if mime is None:
        raise ValueError(f"Use a PNG, JPEG, or WebP file: {path}")
    return mime, base64.b64encode(Path(path).read_bytes()).decode("ascii")


def to_data_url(path):
    """Local file to a data URL for an OpenAI-compatible image_url part."""
    mime, data = _encode(path)
    return f"data:{mime};base64,{data}"


def to_inline_part(path):
    """Local file to a Gemini-native inlineData part."""
    mime, data = _encode(path)
    return {"inlineData": {"mimeType": mime, "data": data}}


if __name__ == "__main__":
    # Save the images in a response file: python nano_banana.py response.json output-name
    body = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
    if "error" in body:
        sys.exit(f"API error: {body['error']}")
    if "choices" in body:
        saved = save_chat_images(body["choices"][0]["message"].get("content"), sys.argv[2])
    else:
        saved = save_native_images(body, sys.argv[2])
    for path in saved:
        print("Saved", path)

• The first image is written as output-name.png (or .jpg or .webp).
• Any further images are written as output-name-2, output-name-3, and so on.

​

Nano Banana Standard

​

Generate an image

from nano_banana import openai_client, save_chat_images

response = openai_client().chat.completions.create(
    model="gemini-2.5-flash-image",
    messages=[{
        "role": "user",
        "content": "Generate an image of a red fox sitting in fresh snow at sunrise, soft golden light.",
    }],
)
for path in save_chat_images(response.choices[0].message.content, "standard-fox"):
    print("Saved", path)

curl --fail-with-body --max-time 300 \
  "https://api.laozhang.ai/v1/chat/completions" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-2.5-flash-image",
    "stream": false,
    "messages": [{
      "role": "user",
      "content": "Generate an image of a red fox sitting in fresh snow at sunrise, soft golden light."
    }]
  }' \
  -o standard-response.json

python nano_banana.py standard-response.json standard-fox

from nano_banana import generate_content, save_native_images

result = generate_content(
    "gemini-2.5-flash-image",
    [{"text": "Generate an image of a lighthouse on a rocky coast at dusk, wide cinematic view."}],
    image_config={"aspectRatio": "16:9"},
)
for path in save_native_images(result, "standard-lighthouse"):
    print("Saved", path)

​

Edit an image

from nano_banana import openai_client, save_chat_images, to_data_url

response = openai_client().chat.completions.create(
    model="gemini-2.5-flash-image",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Replace the background with a plain light-gray studio wall. Keep the product unchanged."},
            {"type": "image_url", "image_url": {"url": to_data_url("product.jpg")}},
        ],
    }],
)
for path in save_chat_images(response.choices[0].message.content, "standard-edit"):
    print("Saved", path)

​

Move to a newer model

from nano_banana import generate_content, save_native_images

result = generate_content(
    "gemini-3.1-flash-image",
    [{"text": "Generate an image of a lighthouse on a rocky coast at dusk, wide cinematic view."}],
    image_config={"aspectRatio": "16:9", "imageSize": "2K"},
)
for path in save_native_images(result, "lighthouse-2k"):
    print("Saved", path)

​

Large images and image URLs

{
  "contents": [{
    "role": "user",
    "parts": [
      {"text": "Dress the person in the first image in the jacket from the second image."},
      {"fileData": {"mimeType": "image/jpeg", "fileUri": "https://cdn.example.com/person.jpg"}},
      {"inlineData": {"mimeType": "image/png", "data": "<Base64 data of the jacket image>"}}
    ]
  }],
  "generationConfig": {"responseModalities": ["IMAGE"]}
}

• It’s a direct HTTPS link that needs no login, cookies, or Referer, and sits behind no CAPTCHA, Cloudflare challenge, or User-Agent filter.
• The site’s robots.txt doesn’t block crawlers from the image’s path.
• A signed URL stays valid long enough to cover queueing and retries; allow at least 30 minutes.
• mimeType matches the real format: image/jpeg for JPEG, image/png for PNG, image/webp for WebP.

​

Troubleshooting

• HTTP 400 with Cannot fetch content from the provided URL. The server couldn’t download the image in fileData. Work through the conditions in Large images and image URLs.
• HTTP 413. The request body is too large. Pass large images by URL with fileData, or downscale them so the whole request stays under 20 MB.
• HTTP 200 but no image. The OpenAI-compatible reply contains only text, or the native response has no inlineData part. The call is already charged, so don’t resend it unchanged; fix the prompt or references as described in Avoid paying for empty responses.
  • In native responses, check finishReason, and promptFeedback if the response includes it.
  • Example values include IMAGE_SAFETY, IMAGE_PROHIBITED_CONTENT, and NO_IMAGE.
• HTTP 401. Check the API key and the Authorization: Bearer header. Use a model API key from Token management, not an account AccessToken.
• HTTP 400. Check the model ID, the JSON body, and that aspectRatio and imageSize are on the model’s list, with an uppercase K.
• HTTP 429, 5xx, or a timeout. Retry with exponential backoff; after a timeout, check call logs first, as described in Billing.

​

FAQ

​

How do I get an API key for Nano Banana?

​

Can I call Nano Banana without a Google account?

​

Which Nano Banana model should I start with?

​

Can the OpenAI-compatible route return 16:9 or 4K images?

​

How much does the Nano Banana API cost per image?

• Nano Banana 2 Lite: $0.025
• Nano Banana 2.1: $0.045
• Nano Banana 2: $0.055
• Nano Banana Pro: $0.09

​

Do output size, references, or editing change the price?

​

Am I charged when a request fails, times out, or returns no image?

​

Can one request return several images?

​

Which prompt languages work best?

​

Do generated images carry a watermark?

​

Which input image formats can I send?

​

Why does a pure white background show dark spots or smudges?

• light gray: light gray background, #F5F5F5
• beige: beige background, #F5F0E5
• light blue: light blue background, #E8F0F8

​

Sources and related pages

• Google: Nano Banana image generation — model names, output sizes, aspect ratios, reference limits, thinking, grounding, supported languages, and SynthID
• Google: image understanding — supported input image formats
• Google: Gemini API pricing — Google’s image model prices and Search grounding charges
• Google: generateContent reference — imageConfig fields and imageSize values
• Google: Gemini API deprecations — upstream model shutdown dates
• Nano Banana image editing (Standard) and Nano Banana Pro image editing — complete editing guides
• Models and pricing — current LaoZhang API prices and groups
• Call logs — find a request’s status and charge
• Gemini protocol and OpenAI protocol — client setup for each route
• Choose an image API — compare Nano Banana with GPT Image 2.5, FLUX.2, and Seedream