E-Commerce-Produktbilder mit Nano-Banana über die hiapi API generieren

Produktfotografie ist die repetitivste Bildarbeit im E-Commerce: dasselbe Produkt, immer und immer wieder fotografiert – Freisteller auf weißem Grund, Lifestyle-Szenen, Verpackungsaufnahmen, Model-Shots, saisonale Varianten. Der schwierige Teil war nie, ein schönes Bild zu erzeugen. Schwierig ist es, auf jedem Bild dasselbe Produkt zu erzeugen, damit deine Produktdetailseite nicht so aussieht, als würdest du fünf leicht unterschiedliche Flaschen verkaufen.

Dieser Leitfaden zeigt einen funktionierenden Ansatz dafür auf der Nano Banana API von hiapi, mit zwei Modellen aus derselben Familie:

• nano-banana – schnelle, günstige Text-zu-Bild-Generierung, $0,021 pro Bild. Damit erstellst du dein Ankerbild.
• Nano-Banana-2 – akzeptiert Referenzbilder über das image_input-Array ($0,036 pro 1K-Bild). Damit setzt du das Ankerbild in alle anderen Szenen neu ein und hältst dabei das Produkt – und sogar echte Models – völlig konsistent.

Jedes Bild unten wurde zum Zeitpunkt der Erstellung dieses Artikels generiert, mit dem exakten Prompt daneben abgedruckt. Das Produkt ist eine für diesen Artikel erfundene Marke („LUMA“).

TL;DR

1. Erzeuge mit nano-banana ($0,021) ein sauberes Ankerbild auf weißem Grund.
2. Hoste es unter einer öffentlichen URL (dein S3/R2/CDN – überall).
3. Übergib diese URL als image_input an Nano-Banana-2 und beschreibe jede neue Szene. Flasche, Etikett und Typografie bleiben unversehrt erhalten.
4. Für Model-Shots wendest du denselben Trick mit einer Person an: Erzeuge einen Model-Shot und referenziere ihn dann, um während der gesamten Kampagne dasselbe Gesicht zu halten.
5. Verarbeite den gesamten Ablauf im Batch über den asynchronen /v1/tasks-Endpunkt – der Code steht am Ende.

Schritt 1 – Das Ankerbild (nano-banana, $0,021)

Beginne mit dem Marktplatz-Produktbild: Produkt zentriert, reinweißer Hintergrund. Dies ist auch das Bild, das alle nachfolgenden Bilder erben, also mach es gut, bevor du weitermachst.

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

Ein Schema-Detail, das dir 400-Fehler erspart: nano-banana unterstützt ausschließlich Text-zu-Bild. Seine Eingabe akzeptiert nur drei Felder – prompt, aspect_ratio und output_format. Wenn du resolution oder ein beliebiges Bildfeld sendest, lehnt die API die Anfrage mit additional properties not allowed ab. Referenzbilder sind die Aufgabe des nächsten Modells.

Schritt 2 – Dieselbe Flasche, neue Szene (Nano-Banana-2 + image_input)

Lade das Ankerbild an eine öffentliche Stelle hoch und übergib seine URL an Nano-Banana-2. Das Feld image_input akzeptiert ein Array von Bild-URLs (keine Dateiinhalte), der Prompt beschreibt die neue Szene. Die entscheidende Formulierung lautet: „diese exakte Flasche, unverändert.“

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

Vergleiche das Etikett mit dem Ankerbild: dieselbe Wortmarke, dieselbe goldene Linie, dieselbe Struktur des Verschlusses. Genau das ist der Unterschied zwischen einem „KI-Produktbild“, das Kunden bemängeln, und einem Bild, das wie eine echte Aufnahme aussieht.

Auf dieselbe Weise funktioniert auch die Verpackung – beschreibe die Box als Erweiterung des Referenzbildes:

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

Schritt 3 – Model-Shots mit konsistentem Gesicht

E-Commerce-Teams fotografieren aus gutem Grund mit demselben Model neu: Eine Kampagne, in der auf jedem Foto eine andere Person zu sehen ist, liest sich wie Stockfotos. Der Referenz-Trick funktioniert auch bei Menschen. Erzeuge zunächst einen Model-Shot, der dein Produkt enthält (hier mit der Ankerflasche als Referenz):

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

Verwende dann dieses Bild als Referenz für die nächste Szene und fordere „dieselbe Frau“:

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

Dasselbe Gesicht, dieselbe Frisur, derselbe Pullover, eine neue Szene. Verkette so viele, wie deine Kampagne benötigt: Jede akzeptierte Ausgabe wird zur Referenz für den nächsten Shot.

API von Anfang bis Ende

Alles läuft über den einheitlichen asynchronen Task-Endpunkt von hiapi. Task erstellen, abfragen, Ausgabe herunterladen. Das Ankerbild in 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"}

Der Aufruf zum Neusetzen unterscheidet sich nur durch den Modellnamen und das image_input-Array:

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"
    }
  }'

Frage GET /v1/tasks/{taskId} ab, bis data.status success (oder fail) ist, und lade dann data.output[0].url herunter. Zwei Hinweise für den Produktivbetrieb:

• Ausgabe-URLs sind temporär – die Antwort enthält einen expireAt-Zeitstempel. Lade die Bytes sofort herunter und lege sie in deinem eigenen Speicher ab; verlinke sie nicht direkt. (Mehr zu diesem Fehlermuster: hiapi-Ausgabe-URL abgelaufen: vor Ablauf herunterladen.)
• Übergib für echte Pipelines das Top-Level-Feld callback.url in der Erstellungsanfrage, statt zu pollen – hiapi ruft deinen Endpunkt auf, sobald der Task einen Endzustand erreicht.

Die Läufe hinter diesem Artikel waren jeweils in deutlich unter zwei Minuten abgeschlossen.

Batch-Skript: ein Ankerbild, ein ganzer Katalog

Das Muster skaliert linear: pro SKU ein Ankerbild + N Neusetzungen. Hier eine kompakte, lauffähige Version:

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

Die Tasks werden im Voraus erstellt und auf der hiapi-Seite parallel generiert; anschließend sammelt die Schleife sie der Reihe nach ein. Füge callback.url in die Erstellungs-Payload ein, und sobald du einen Webhook-Empfänger hast, entferne wait() komplett.

Kostenrechnung für einen echten Katalog

Die folgenden Preise stammen von der zum Zeitpunkt der Erstellung aktuellen hiapi-Preisseite – betrachte diese Seite als maßgebliche Quelle:

Modell	Rolle in diesem Workflow	Preis
nano-banana	Ankerbild, schnelle Entwürfe (nur Text-zu-Bild)	$0,021 / Bild
Nano-Banana-2	Referenzbasiertes Neusetzen (image_input)	$0,036 pro Bild in 1K, $0,086 pro Bild in 4K
Nano-Banana-Pro	Bearbeitung mit höchster Detailtreue, bis zu 8 Referenzbilder	$0,057 pro Bild in 1K

Ein Katalog mit 40 SKUs, je ein Ankerbild und vier neu gesetzte Aufnahmen pro SKU:

• 40 Ankerbilder × $0,021 = $0,84
• 160 Neusetzungen × $0,036 = $5,76
• Gesamt: $6,60 für einen visuell konsistenten Katalog mit 200 Bildern – kein Studio-Tag, keine Neuaufnahmen, wenn sich eine Szene ändern muss.

Zwei praktische Ratschläge für Shops. Erstens: Die Ausgabe sind gewöhnliche Bilddateien, die dir geliefert werden – du hostest sie auf deinem eigenen CDN, sodass nichts in deinem Stack deine Produkteinträge an einen Drittanbieter-Viewer bindet. Zweitens: Generierte „Model“-Bilder sind synthetisch – die Frau oben existiert nicht, was die Logistik von Model-Release-Formularen umgeht –, aber bevor du generierte Bilder auf einem Live-Storefront veröffentlichst, prüfe die aktuellen Bedingungen des zugrunde liegenden Anbieters (Google) und die KI-Bild-Richtlinien deines Marktes.

Zusammenfassung

Der Workflow, der Nano Banana für den E-Commerce nützlich macht, ist kein einzelner Zauber-Prompt – es ist der Kreislauf aus Verankern und Neusetzen: Kaufe für $0,021 ein gutes Produktbild von nano-banana und lass dann Nano-Banana-2 genau dieses Produkt (und genau dieses Gesicht) durch jede Szene führen, die dein Shop benötigt. Wir haben denselben Kreislauf in gpt-image-2 E-Commerce-Produktbilder: Batch-Workflow auf hiapi mit einem anderen Modell durchlaufen, falls du die Ausgaben vergleichen möchtest, bevor du dich festlegst.

Um diesen Kreislauf selbst auszuprobieren, hole dir einen API-Schlüssel, beginne mit einer SKU und führe das obige Batch-Skript aus – die Nano Banana Modellseite bietet einen Live-Playground und Copy-Paste-Beispiele, die in unter einer Minute ein erstes Ankerbild ausgeben.