Using Nano-Banana-2-Lite for E-Commerce Product Images via the hiapi API

When you generate product images for an e-commerce catalog, the unit economics matter more than any single image. A hero shot that costs $0.17 is fine when you need ten of them; it is a very different conversation when you need three shots for each of a thousand SKUs. That is the slot Nano-Banana-2-Lite fills on hiapi: $0.033 per image at 1K resolution, with the same async task API as the bigger Nano-Banana models and support for up to 10 reference images — enough to run the classic e-commerce trio of white-background hero, lifestyle scene, and premium dark variant at bulk prices.

This guide is the budget-tier companion to our earlier Nano-Banana e-commerce workflow. Everything below — requests, outputs, timings, costs — comes from runs we did against the live API while writing this post.

Where Lite sits in the Nano-Banana lineup

Verified against the hiapi pricing page at the time of writing:

The decision rule for catalogs is simple:

• Marketplace listings, long-tail SKUs, A/B variants → Lite. At 1K (roughly 1024px on the short edge) the output is at or above what most marketplaces compress your uploads to anyway.
• Homepage banners, campaign key visuals, print → step up to nano-banana-pro for 2K/4K output and stronger text rendering. Lite for volume, Pro for the money shots — they complement rather than compete.

One working request

Nano-Banana-2-Lite runs on hiapi's unified async task API: submit a task, poll until it finishes, download the result. Three gotchas before the code:

1. The model id is case-sensitive. Send Nano-Banana-2-Lite exactly — lowercase variants return 400 MODEL_UNAVAILABLE.
2. aspect_ratio is an enum, not free-form. Allowed values: auto, 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9, 1:4, 4:1, 1:8, 8:1. There is no resolution field — Lite is fixed at 1K, and sending resolution gets your request rejected.
3. Output URLs are signed and expire. Download the bytes as soon as the task succeeds; store the file, not the URL.

curl -s -X POST https://api.hiapi.ai/v1/tasks \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Nano-Banana-2-Lite",
    "input": {
      "prompt": "Professional e-commerce product photo of a minimalist matte-white wireless earbuds charging case, centered on a seamless pure white background, soft even studio lighting, gentle shadow beneath, crisp edges, catalog-ready hero shot, no text, no logo",
      "aspect_ratio": "1:1"
    }
  }'

The response contains a taskId. Poll GET /v1/tasks/{taskId} until status is success, then download data.output[0].url. In our runs a single task completed in roughly 55–65 seconds end to end, including polling.

Here is that exact prompt's output — an unretouched Lite generation:

Prompting for catalog-grade hero shots

For white-background listings, the prompt pattern that worked consistently for us:

Professional e-commerce product photo of [product, materials, colors], centered on a seamless pure white background, soft even studio lighting, subtle natural shadow, crisp focus, marketplace catalog style, no text, no logo

Two more products from the same template, changing only the product description and aspect ratio (4:5 suits fashion/beauty verticals, 4:3 suits footwear and electronics):

Practical notes from the batch:

• Always end with "no text, no logo". Like most image models, Lite will otherwise happily invent label typography and brand marks — a compliance problem on real listings. If your product has a real label, composite it afterwards or use the reference-image path below.
• Ask for the shadow explicitly ("subtle natural shadow"). Without it you tend to get a floating cut-out look that reads as fake on marketplaces.
• One product per image. Lite handles single-subject compositions reliably; multi-product flat lays are where you start wanting the bigger models.

Same product, new scenes: the image_urls workflow

The real e-commerce trick is consistency: one canonical product shot, re-staged into lifestyle and premium contexts without the product morphing between images. Lite accepts up to 10 reference images through the image_urls field (note: the bigger Nano-Banana-2 models call this field image_input — the rename is the main porting gotcha, covered in our Lite API tutorial).

We passed the hero shot above as the reference and asked for two re-stagings:

{
  "model": "Nano-Banana-2-Lite",
  "input": {
    "prompt": "Place this exact product on a warm oak wooden desk next to a laptop keyboard and a small green potted plant, soft morning window light from the left, shallow depth of field, cozy home-office lifestyle e-commerce scene, keep the product design, colors and proportions unchanged",
    "aspect_ratio": "4:3",
    "image_urls": ["https://your-cdn.example.com/hero-earbuds.jpg"]
  }
}

Both variants came back with the case's proportions, lid seam and indicator LED intact. The phrase "keep the product design, colors and proportions unchanged" pulls a lot of weight here — include it in every reference-image prompt. Reference URLs must be publicly fetchable (signed private links that expire mid-task will fail the job).

A batch pipeline in Python

Tasks are independent, so batch throughput comes from submitting them all up front and polling as a group — five concurrent tasks finished in about the same wall-clock time as one in our runs. A minimal pipeline:

import json
import subprocess
import time

API = "https://api.hiapi.ai/v1/tasks"
TOKEN = "sk-..."  # your hiapi API key

def _curl(args):
    out = subprocess.run(["curl", "-s", *args], capture_output=True, text=True, timeout=90)
    return json.loads(out.stdout)

def submit(prompt, aspect_ratio="1:1", image_urls=None):
    inp = {"prompt": prompt, "aspect_ratio": aspect_ratio}
    if image_urls:
        inp["image_urls"] = image_urls
    data = _curl(["-X", "POST", API,
                  "-H", f"Authorization: Bearer {TOKEN}",
                  "-H", "Content-Type: application/json",
                  "-d", json.dumps({"model": "Nano-Banana-2-Lite", "input": inp})])
    return data["data"]["taskId"]

def wait(task_id, timeout_s=600):
    deadline = time.time() + timeout_s
    while time.time() < deadline:
        task = _curl([f"{API}/{task_id}", "-H", f"Authorization: Bearer {TOKEN}"])["data"]
        if task["status"] == "success":
            return task["output"][0]["url"]
        if task["status"] == "fail":
            raise RuntimeError(f"{task_id}: {task.get('error')}")
        time.sleep(5)
    raise TimeoutError(task_id)

HERO_TMPL = ("Professional e-commerce product photo of {product}, centered on a "
             "seamless pure white background, soft even studio lighting, subtle "
             "natural shadow, crisp focus, marketplace catalog style, no text, no logo")

skus = [
    {"id": "SKU-001", "product": "a matte-white wireless earbuds charging case"},
    {"id": "SKU-002", "product": "an amber glass serum bottle with black dropper cap"},
    {"id": "SKU-003", "product": "a white minimalist running sneaker with light gray sole"},
]

# 1) submit everything up front
tasks = {sku["id"]: submit(HERO_TMPL.format(product=sku["product"])) for sku in skus}

# 2) collect results and persist bytes immediately — output URLs expire
for sku_id, task_id in tasks.items():
    url = wait(task_id)
    subprocess.run(["curl", "-s", "-o", f"{sku_id}.jpg", url], timeout=120)
    print(f"{sku_id} done")

For production volume, two upgrades are worth making: use webhook callbacks instead of polling (pass callback.url with when: "final" when creating the task), and persist each taskId next to your SKU record so a crashed worker can resume instead of double-spending. Both are covered in the task API tutorial and the hiapi docs.

What a catalog actually costs

At $0.033 per image, with the standard three-shot treatment (hero + lifestyle + dark/detail variant):

A sensible hybrid: run the whole catalog through Lite, then re-shoot only your top-20 revenue SKUs on nano-banana-pro at 2K/4K for homepage and campaign placements. For the 100-SKU example that is $9.90 + about $10 of Pro images — still a fraction of a single studio day.

Budget a retry margin of 5–10% for prompts that need a second attempt (usually stray text on labels), and remember failed tasks are reported as fail with an error object — only successful generations are worth wiring into your quality gate.

Wrap-up

Nano-Banana-2-Lite will not replace your flagship key-visual pipeline — that is what the Pro tier is for. But for the long tail of a catalog, where every SKU needs presentable, consistent imagery and the budget is measured per thousand images, $0.033 at 1K with reference-image support is hard to argue with.

Grab an API key, then start with the Nano-Banana-2-Lite model page — the request above works as-is once you swap in your token, and the batch script scales it from one SKU to a thousand.