Generare immagini di prodotto per l'e-commerce con Nano-Banana tramite l'API hiapi

La fotografia di prodotto è il lavoro di immagini più ripetitivo nell'e-commerce: lo stesso prodotto, fotografato ancora e ancora — immagine su fondo bianco, immagine in contesto, immagine della confezione, immagine con modella, varianti stagionali. La parte difficile non è mai stata generare una bella immagine. La parte difficile è generare lo stesso prodotto in ogni immagine, così che la tua pagina di dettaglio del prodotto non sembri la vetrina di cinque bottiglie leggermente diverse.

Questa guida mostra il percorso praticabile per ottenerlo sull'API Nano Banana di hiapi, usando due modelli della stessa famiglia:

• nano-banana — generazione testo-immagine veloce ed economica, $0.021 per immagine. Usalo per creare la tua immagine di ancoraggio.
• Nano-Banana-2 — accetta immagini di riferimento tramite l'array image_input ($0.036 per immagine 1K). Usalo per riposizionare l'immagine di ancoraggio in tutte le altre scene, mantenendo il prodotto — e persino una modella reale — perfettamente coerenti.

Ogni immagine qui sotto è stata generata al momento della stesura di questo articolo, con accanto il prompt esatto. Il prodotto è un marchio inventato per questo articolo ("LUMA").

TL;DR

1. Genera un'immagine di ancoraggio pulita su fondo bianco con nano-banana ($0.021).
2. Pubblicala su un URL pubblico (il tuo S3/R2/CDN — ovunque vada bene).
3. Passa quell'URL come image_input a Nano-Banana-2 e descrivi ogni nuova scena. La bottiglia, l'etichetta e la tipografia vengono preservate intatte.
4. Per le immagini con modella, usa lo stesso trucco con una persona: genera un'immagine della modella, poi riferisciti a essa per mantenere lo stesso viso in tutta la campagna.
5. Elabora in batch l'intero flusso con l'endpoint asincrono /v1/tasks — il codice è in fondo.

Passo 1 — L'immagine di ancoraggio (nano-banana, $0.021)

Parti dalla foto per la scheda del marketplace: prodotto centrato, sfondo bianco puro. È anche l'immagine che tutte le successive erediteranno, quindi falla bene prima di espandere.

Professional e-commerce product photograph of a 30ml amber glass serum bottle
with a matte black dropper cap, minimalist off-white label with the word LUMA
in small black sans-serif letters and a thin gold accent line, centered on a
pure white seamless background, soft even studio lighting, gentle shadow under
the bottle, crisp focus, high-end skincare catalog style

Un dettaglio dello schema che ti aiuta a evitare errori 400: nano-banana supporta solo la generazione testo-immagine. Il suo input accetta solo tre campi — prompt, aspect_ratio e output_format. Se invii resolution o qualsiasi campo immagine, l'API rifiuta la richiesta con additional properties not allowed. Le immagini di riferimento sono compito del modello successivo.

Passo 2 — La stessa bottiglia, nuove scene (Nano-Banana-2 + image_input)

Carica l'immagine di ancoraggio in una posizione pubblica, poi passa il suo URL a Nano-Banana-2. Il campo image_input accetta un array di URL di immagini (non il contenuto dei file), e il prompt descrive la nuova scena. La frase chiave che funziona è: "questa esatta bottiglia, invariata".

Place this exact serum bottle, unchanged — same amber glass, same black
dropper cap, same off-white LUMA label with the thin gold line — on a
white marble bathroom counter next to a folded beige linen towel and a
small eucalyptus sprig, soft warm morning window light from the left,
shallow depth of field, premium skincare lifestyle photography

Confronta l'etichetta con l'immagine di ancoraggio: stesso wordmark, stessa linea dorata, stessa texture del tappo. È questa la differenza tra una "immagine di prodotto AI" che il cliente nota e un'immagine che sembra scattata davvero.

Lo stesso vale per la confezione — descrivi la scatola come estensione dell'immagine di riferimento:

Product family shot: this exact serum bottle — same amber glass, black dropper
cap, off-white LUMA label with thin gold line — standing next to its matching
retail packaging, a matte off-white rectangular box with the same LUMA wordmark
and thin gold accent line, both centered on a pale warm-grey studio background
with soft shadows, symmetrical composition, premium skincare packaging photography

Passo 3 — Immagini con modella a viso coerente

I team e-commerce rifotografano con la stessa modella per un motivo: una campagna in cui ogni foto mostra una persona diversa si legge come immagini stock. La tecnica del riferimento funziona anche con le persone. Prima, genera un'immagine con una modella che tiene il tuo prodotto (questa usa la bottiglia di ancoraggio come riferimento):

A young woman with shoulder-length dark hair, wearing a plain sand-colored knit
sweater, holding this exact serum bottle — same amber glass, same black dropper
cap, same off-white LUMA label with the thin gold line — up near her cheek at a
slight angle, looking at the camera with a soft natural smile, clean warm beige
studio background, soft diffused beauty lighting, e-commerce model shot for a
skincare brand

Poi usa quell'immagine come riferimento per la scena successiva e chiedi "la stessa donna":

The same woman from the reference image — identical face, same shoulder-length
dark hair, same sand-colored knit sweater — now standing at a bright bathroom
mirror, applying one drop of serum from the same amber LUMA dropper bottle onto
the back of her hand, seen in a relaxed three-quarter view, soft morning light,
candid lifestyle e-commerce campaign photo

Stesso viso, stessa acconciatura, stesso maglione, nuova scena. Concatena quanto ti serve per la tua campagna: ogni output accettato diventa il riferimento per lo scatto successivo.

L'API end-to-end

Tutto passa dall'endpoint unificato di attività asincrone di hiapi. Crea l'attività, esegui il polling, scarica l'output. L'immagine di ancoraggio con curl:

curl -X POST "https://api.hiapi.ai/v1/tasks" \
  -H "Authorization: Bearer $HIAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nano-banana",
    "input": {
      "prompt": "Professional e-commerce product photograph of ...",
      "aspect_ratio": "1:1",
      "output_format": "png"
    }
  }'
# -> {"code": 200, "data": {"taskId": "tk-hiapi-01KWK4E5WG..."}, "message": "success"}

La chiamata di riposizionamento differisce solo nel nome del modello e nell'array image_input:

curl -X POST "https://api.hiapi.ai/v1/tasks" \
  -H "Authorization: Bearer $HIAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Nano-Banana-2",
    "input": {
      "prompt": "Place this exact serum bottle, unchanged — ... on a white marble bathroom counter ...",
      "image_input": ["https://your-cdn.example.com/luma/anchor.jpg"],
      "aspect_ratio": "4:3",
      "resolution": "1K",
      "output_format": "png"
    }
  }'

Esegui il polling di GET /v1/tasks/{taskId} finché data.status non è success (o fail), poi scarica data.output[0].url. Due avvertenze per la produzione:

• Gli URL di output sono temporanei — la risposta contiene un timestamp expireAt. Scarica subito i byte e archiviali sul tuo storage; non fare hotlinking. (Maggiori dettagli su questa modalità di errore: URL di output hiapi scaduto: scarica prima della scadenza.)
• Per pipeline reali, passa un callback.url di primo livello nella richiesta di creazione invece del polling — hiapi chiamerà il tuo endpoint quando l'attività raggiunge lo stato finale.

Le esecuzioni alla base di questo articolo si sono completate tutte in molto meno di due minuti.

Script batch: un'immagine di ancoraggio, un intero catalogo

Il pattern scala in modo lineare: per ogni SKU, un'immagine di ancoraggio + N riposizionamenti. Ecco una versione compatta e funzionante:

import requests, time, pathlib

API = "https://api.hiapi.ai/v1/tasks"
HEADERS = {"Authorization": "Bearer YOUR_API_KEY", "Content-Type": "application/json"}

SCENES = {
    "lifestyle": ("Place this exact product, unchanged — same bottle, same label — on a "
                  "white marble bathroom counter, soft morning window light, shallow depth "
                  "of field, premium lifestyle photography", "4:3"),
    "packaging": ("Product family shot: this exact product next to its matching retail box "
                  "with the same wordmark, pale warm-grey studio background, symmetrical "
                  "composition, premium packaging photography", "3:2"),
    "hand":      ("A hand with neutral manicure holding this exact product, unchanged, "
                  "against a clean warm beige background, soft diffused light", "3:4"),
}

def create(model, inp):
    r = requests.post(API, headers=HEADERS, json={"model": model, "input": inp}, timeout=60)
    r.raise_for_status()
    return r.json()["data"]["taskId"]

def wait(task_id, timeout=600):
    deadline = time.time() + timeout
    while time.time() < deadline:
        d = requests.get(f"{API}/{task_id}", headers=HEADERS, timeout=30).json()["data"]
        if d["status"] == "success":
            return d["output"][0]["url"]
        if d["status"] == "fail":
            raise RuntimeError(f"{task_id}: {d.get('error')}")
        time.sleep(5)
    raise TimeoutError(task_id)

def shoot_sku(sku: str, anchor_url: str, outdir="shots"):
    """anchor_url: your hosted white-background shot for this SKU."""
    tasks = {name: create("Nano-Banana-2", {
                 "prompt": prompt, "image_input": [anchor_url],
                 "aspect_ratio": ar, "resolution": "1K", "output_format": "png"})
             for name, (prompt, ar) in SCENES.items()}
    pathlib.Path(outdir).mkdir(exist_ok=True)
    for name, tid in tasks.items():           # tasks run server-side in parallel
        url = wait(tid)                        # download before the URL expires
        img = requests.get(url, timeout=120).content
        pathlib.Path(f"{outdir}/{sku}-{name}.png").write_bytes(img)
        print(f"{sku}/{name}: {len(img)} bytes")

shoot_sku("luma-serum-30ml", "https://your-cdn.example.com/luma/anchor.jpg")

Le attività vengono create in anticipo e generate in parallelo lato hiapi; poi il ciclo le raccoglie in ordine. Aggiungi callback.url al payload di creazione e rimuovi del tutto wait() una volta che hai un ricevitore di webhook.

Calcolo dei costi per un catalogo reale

I prezzi seguenti provengono dalla pagina dei prezzi di hiapi in tempo reale al momento della stesura — considera quella pagina come fonte di verità:

Modello	Ruolo in questo flusso di lavoro	Prezzo
nano-banana	Immagine di ancoraggio, bozze rapide (solo testo-immagine)	$0.021 / immagine
Nano-Banana-2	Riposizionamento basato su riferimento (image_input)	$0.036 per 1K, $0.086 per 4K
Nano-Banana-Pro	Editing ad altissima fedeltà, fino a 8 immagini di riferimento	$0.057 per 1K

Un catalogo di 40 SKU, con un'immagine di ancoraggio e quattro scatti riposizionati per SKU:

• 40 immagini di ancoraggio × $0.021 = $0.84
• 160 riposizionamenti × $0.036 = $5.76
• Totale: $6.60 per un catalogo di 200 immagini visivamente coerenti — senza giornate in studio, senza rifacimenti quando le scene devono cambiare.

Due consigli pratici per il tuo negozio. Primo, gli output sono normali file immagine consegnati a te — li ospiti sul tuo CDN, quindi nulla nello stack lega le tue schede prodotto a un visualizzatore di terze parti. Secondo, le immagini generate di "modelle" sono sintetiche: la donna qui sopra non esiste, il che aggira la logistica delle liberatorie — ma prima di promuovere immagini generate sul negozio live, controlla i termini attuali del provider sottostante (Google) e le normative del tuo mercato sulle immagini AI.

In sintesi

Il flusso di lavoro che rende Nano Banana utile per l'e-commerce non è un singolo prompt magico — è il ciclo di ancoraggio e riposizionamento: spendi $0.021 con nano-banana per una buona foto di prodotto, poi lascia che Nano-Banana-2 porti quel prodotto esatto (e quel viso esatto) in ogni scena di cui il tuo negozio ha bisogno. Abbiamo eseguito lo stesso ciclo con modelli diversi in gpt-image-2 immagini di prodotto e-commerce: flusso di lavoro in batch su hiapi, se vuoi confrontare gli output prima di impegnarti.

Per provare il ciclo da solo, ottieni una chiave API, parti da un SKU, esegui lo script batch qui sopra — la pagina dei modelli Nano Banana ha un playground live ed esempi pronti da copiare che producono la prima immagine di ancoraggio in meno di un minuto.