Générer des visuels produits e-commerce avec Nano-Banana via l'API hiapi

La photographie produit est le travail d'image le plus répétitif du e-commerce : le même produit, photographié encore et encore — packshots sur fond blanc, mises en situation, packaging, mannequins, variantes saisonnières. La partie difficile n'a jamais été de générer une belle image. La difficulté, c'est de générer le même produit sur chaque image, pour que votre fiche produit ne donne pas l'impression de vendre cinq flacons légèrement différents.

Ce guide montre comment y parvenir sur l'API Nano Banana de hiapi, avec deux modèles de la même famille :

• nano-banana — génération d'images à partir de texte, rapide et économique, 0,021 $ par image. À utiliser pour créer votre image d'ancrage.
• Nano-Banana-2 — accepte des images de référence via le tableau image_input (0,036 $ par image 1K). À utiliser pour replacer l'image d'ancrage dans tous les autres contextes, tout en conservant le produit — et même de vrais mannequins — parfaitement identiques.

Chaque image ci-dessous a été générée au moment de la rédaction de cet article, avec le prompt exact imprimé à côté. Le produit appartient à une marque fictive créée pour cet article (« LUMA »).

TL;DR

1. Générez une image d'ancrage propre sur fond blanc avec nano-banana (0,021 $).
2. Hébergez-la sur une URL publique (votre S3/R2/CDN — n'importe où).
3. Passez cette URL comme image_input à Nano-Banana-2 et décrivez chaque nouvelle scène. Le flacon, l'étiquette et la typographie sont conservés à l'identique.
4. Pour les visuels avec mannequin, appliquez la même astuce avec une personne : générez une image de mannequin, puis référencez-la pour conserver le même visage tout au long de la campagne.
5. Traitez l'ensemble du pipeline en lot via le point de terminaison asynchrone /v1/tasks — le code se trouve en bas.

Étape 1 — L'image d'ancrage (nano-banana, 0,021 $)

Commencez par un visuel de fiche produit : produit centré, fond blanc pur. C'est aussi l'image dont hériteront toutes les suivantes, alors soignez-la avant de vous lancer.

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 détail de schéma qui vous évitera les erreurs 400 : nano-banana ne prend en charge que la génération d'images à partir de texte. Son entrée n'accepte que trois champs — prompt, aspect_ratio et output_format. Si vous envoyez resolution ou un quelconque champ d'image, l'API rejette la requête avec additional properties not allowed. Les images de référence relèvent du modèle suivant.

Étape 2 — Le même flacon, de nouvelles scènes (Nano-Banana-2 + image_input)

Uploadez l'image d'ancrage à un emplacement public, puis transmettez son URL à Nano-Banana-2. Le champ image_input accepte un tableau d'URL d'images (pas le contenu des fichiers), et le prompt décrit la nouvelle scène. La phrase clé qui fait la différence : « ce flacon exact, inchangé. »

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

Comparez l'étiquette avec celle de l'image d'ancrage : même logotype, même ligne dorée, même motif sur le bouchon. C'est la différence entre un « visuel produit généré par IA » que les clients repèrent et une image qui ressemble à une vraie prise de vue.

Même principe pour le packaging — décrivez la boîte comme un prolongement de l'image de référence :

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

Étape 3 — Des visuels mannequin avec un visage cohérent

Les équipes e-commerce refont poser le même mannequin pour une bonne raison : une campagne où chaque photo montre une personne différente ressemble à de la banque d'images. La technique de référence fonctionne aussi pour les personnes. D'abord, générez un visuel de mannequin avec votre produit (celui-ci utilise le flacon d'ancrage comme référence) :

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

Utilisez ensuite cette image comme référence pour la scène suivante, et demandez « la même femme » :

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

Même visage, même coiffure, même pull, nouvelle scène. Enchaînez autant de références que votre campagne l'exige : chaque sortie acceptée devient la référence du plan suivant.

L'API de bout en bout

Tout passe par le point de terminaison unifié de tâches asynchrones de hiapi. Créez la tâche, interrogez-la, téléchargez la sortie. L'image d'ancrage en 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"}

L'appel de replacement ne diffère que par le nom du modèle et le tableau 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"
    }
  }'

Interrogez GET /v1/tasks/{taskId} jusqu'à ce que data.status passe à success (ou fail), puis téléchargez data.output[0].url. Deux points de vigilance en production :

• Les URL de sortie sont temporaires — la réponse contient un horodatage expireAt. Téléchargez immédiatement les octets et stockez-les sur votre propre stockage ; ne faites pas de hotlinking. (Pour en savoir plus sur ce mode de défaillance : URL de sortie hiapi expirée : télécharger avant l'expiration.)
• Pour un vrai pipeline, passez un callback.url de premier niveau dans la requête de création plutôt que d'interroger — hiapi appelle votre point de terminaison lorsque la tâche atteint son état final.

Les exécutions qui sous-tendent cet article se sont chacune terminées bien en moins de deux minutes.

Script de traitement par lots : une image d'ancrage, tout un catalogue

Le schéma passe à l'échelle de façon linéaire : pour chaque SKU, une image d'ancrage + N replacements. Voici une version compacte et exécutable :

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")

Les tâches sont créées à l'avance et générées en parallèle côté hiapi ; la boucle les collecte ensuite séquentiellement. Ajoutez callback.url dans la charge utile de création et supprimez complètement wait() dès que vous disposez d'un récepteur de webhook.

Calcul de coût pour un catalogue réel

Les tarifs ci-dessous proviennent de la page de tarification hiapi en vigueur au moment de la rédaction — considérez cette page comme la source de vérité :

Modèle	Rôle dans ce workflow	Tarif
nano-banana	Image d'ancrage, brouillons rapides (texte vers image uniquement)	0,021 $ / image
Nano-Banana-2	Replacement basé sur référence (image_input)	0,036 $ l'image en 1K, 0,086 $ l'image en 4K
Nano-Banana-Pro	Retouche à fidélité maximale, jusqu'à 8 images de référence	0,057 $ / image en 1K

Pour un catalogue de 40 SKU, avec une image d'ancrage et quatre prises replacement par SKU :

• 40 images d'ancrage × 0,021 $ = 0,84 $
• 160 replacements × 0,036 $ = 5,76 $
• Total : 6,60 $ pour un catalogue de 200 images visuellement cohérent — sans journée en studio, sans nouvelle prise de vue quand une scène doit changer.

Deux conseils pratiques pour une boutique. D'abord, les sorties sont de simples fichiers image livrés entre vos mains — vous les hébergez sur votre propre CDN, donc rien dans votre stack ne lie vos fiches produit à un visualiseur tiers. Ensuite, les images de « mannequin » générées sont synthétiques : la femme ci-dessus n'existe pas, ce qui contourne la logistique des autorisations de mannequin — mais avant de diffuser des images générées sur une boutique en ligne, consultez les conditions actuelles du fournisseur sous-jacent (Google) et les règles de votre marché en matière d'images générées par IA.

En résumé

Ce qui rend Nano Banana utile pour le e-commerce n'est pas un prompt magique unique — c'est la boucle d'ancrage et de replacement : dépensez 0,021 $ sur nano-banana pour obtenir un bon visuel produit, puis laissez Nano-Banana-2 décliner ce produit exact (et ce visage exact) dans toutes les scènes dont votre boutique a besoin. Nous avons appliqué la même boucle avec un autre modèle dans gpt-image-2 pour les visuels produits e-commerce : un workflow par lots sur hiapi, si vous souhaitez comparer les sorties avant de vous engager.

Pour essayer cette boucle vous-même, obtenez une clé API, commencez par un seul SKU et exécutez le script de traitement par lots ci-dessus — la page du modèle Nano Banana propose un playground en direct et des exemples prêts à copier-coller pour produire votre première image d'ancrage en moins d'une minute.