Genera imágenes de productos de comercio electrónico con Nano-Banana a través de la API de hiapi

La fotografía de producto es el trabajo de imágenes más repetitivo del comercio electrónico: el mismo producto, fotografiado una y otra vez —imágenes de producto sobre fondo blanco, imágenes de estilo de vida, imágenes de empaque, imágenes con modelos, variantes de temporada. La parte difícil nunca ha sido generar una imagen bonita. Lo difícil es generar el mismo producto en cada imagen, para que tu página de detalles de producto no parezca que está vendiendo cinco frascos ligeramente distintos.

Esta guía muestra una solución viable implementada sobre la API de Nano Banana de hiapi, usando dos modelos de la misma familia:

• nano-banana — generación de imágenes a partir de texto rápida y económica, $0.021 por imagen. Úsalo para crear tu imagen de anclaje.
• Nano-Banana-2 — acepta imágenes de referencia mediante el arreglo image_input ($0.036 por imagen 1K). Úsalo para recolocar la imagen de anclaje en todos los demás escenarios, manteniendo el producto —e incluso modelos humanos reales— completamente consistentes.

Cada imagen a continuación se generó en el momento de escribir este artículo, con el prompt exacto impreso al lado. El producto es una marca ficticia creada para este artículo ("LUMA").

TL;DR

1. Genera una imagen de anclaje limpia sobre fondo blanco con nano-banana ($0.021).
2. Alójala en una URL pública (tu S3/R2/CDN —donde sea).
3. Pasa esa URL como image_input a Nano-Banana-2 y describe cada nuevo escenario. El frasco, la etiqueta y la tipografía se conservan intactos.
4. Para las imágenes con modelos, usa la misma técnica con una persona: genera una imagen de modelo y luego referénciala para mantener el mismo rostro en toda la campaña.
5. Procesa todo el flujo por lotes con el endpoint asíncrono /v1/tasks —el código está al final.

Paso 1 — La imagen de anclaje (nano-banana, $0.021)

Comienza con la imagen de listado de marketplace: producto centrado, fondo blanco puro. Esta es también la imagen que heredarán todas las imágenes posteriores, así que hazla bien antes de expandir.

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 detalle de esquema que te ayudará a evitar errores 400: nano-banana solo admite generación de imágenes a partir de texto. Su entrada acepta solo tres campos —prompt, aspect_ratio y output_format. Si envías resolution o cualquier campo de imagen, la API rechaza la solicitud con additional properties not allowed. Las imágenes de referencia son trabajo del siguiente modelo.

Paso 2 — El mismo frasco, nuevo escenario (Nano-Banana-2 + image_input)

Sube la imagen de anclaje a alguna ubicación pública y luego pasa su URL a Nano-Banana-2. El campo image_input acepta un arreglo de URLs de imágenes (no contenido de archivos), y el prompt describe el nuevo escenario. La frase clave que hace que funcione es: "este frasco exacto, sin cambios".

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

Compara la etiqueta con la imagen de anclaje: el mismo logotipo de texto, la misma línea dorada, el mismo relieve de la tapa. Esa es la diferencia entre una "imagen de producto con IA" que los clientes detectan y una imagen que parece una sesión real.

El empaque funciona de la misma manera —describe la caja como una extensión de la imagen de referencia:

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

Paso 3 — Imágenes con modelos de rostro consistente

Los equipos de comercio electrónico vuelven a fotografiar con el mismo modelo por una razón: una campaña en la que cada foto muestra a una persona distinta se lee como imágenes de stock. La técnica de referencia también funciona con personas. Primero, genera una imagen de modelo que incluya tu producto (esta usa el frasco de anclaje como referencia):

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

Luego usa esa imagen como referencia para el siguiente escenario y pide "la misma mujer":

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

El mismo rostro, el mismo peinado, el mismo suéter, un nuevo escenario. Encadena tantas como necesite tu campaña: cada salida aceptada se convierte en la referencia para la siguiente toma.

La API de extremo a extremo

Todo se ejecuta a través del endpoint unificado de tareas asíncronas de hiapi. Crea la tarea, consulta su estado y descarga la salida. La imagen de anclaje 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"}

La llamada de recolocación solo cambia el nombre del modelo y el arreglo 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"
    }
  }'

Consulta GET /v1/tasks/{taskId} hasta que data.status sea success (o fail), y luego descarga data.output[0].url. Dos advertencias para producción:

• Las URL de salida son temporales —la respuesta incluye una marca de tiempo expireAt. Descarga los bytes de inmediato y alóljalos en tu propio almacenamiento; no hagas hotlinking. (Más sobre este modo de fallo: La URL de salida de hiapi ha expirado: descarga antes de que expire.)
• Para un pipeline real, pasa un callback.url de nivel superior en la solicitud de creación en lugar de consultar: hiapi llamará a tu endpoint cuando la tarea alcance el estado final.

Cada una de las ejecuciones detrás de este artículo se completó en mucho menos de dos minutos.

Script por lotes: una imagen de anclaje, todo un catálogo

El patrón escala de forma lineal: para cada SKU, una imagen de anclaje + N recolocaciones. Aquí tienes una versión compacta y ejecutable:

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

Las tareas se crean de antemano y se generan de forma concurrente en el lado de hiapi; luego el bucle las recopila en orden. Agrega callback.url a la carga de creación y, una vez que tengas un receptor de webhook, elimina por completo wait().

Cálculo de costos para un catálogo real

Los siguientes precios provienen de la página de precios de hiapi en vivo al momento de escribir —considera esa página como la fuente de verdad:

Modelo	Rol en este flujo de trabajo	Precio
nano-banana	Imagen de anclaje, borradores rápidos (solo generación de imágenes a partir de texto)	$0.021 / imagen
Nano-Banana-2	Recolocación basada en referencia (image_input)	$0.036 por imagen 1K, $0.086 por imagen 4K
Nano-Banana-Pro	Edición de máxima fidelidad, hasta 8 imágenes de referencia	$0.057 por imagen 1K

Un catálogo de 40 SKU, con una imagen de anclaje y cuatro tomas recolocadas por SKU:

• 40 imágenes de anclaje × $0.021 = $0.84
• 160 recolocaciones × $0.036 = $5.76
• Total: $6.60 por un catálogo de 200 imágenes visualmente consistentes —sin día de estudio fotográfico, sin nuevas sesiones cuando cambien los escenarios.

Dos consejos prácticos para tu tienda. Primero, las salidas son archivos de imagen normales que se te entregan —los alojas en tu propia CDN, así que nada en tu stack ata tus listados de productos a un visor de terceros. Segundo, las imágenes de "modelos" generadas son sintéticas: la mujer de arriba no existe, lo que evita la logística de cesión de derechos de imagen —pero antes de promover imágenes generadas en una tienda en vivo, revisa los términos vigentes del proveedor subyacente (Google) y las políticas de imágenes con IA de tu mercado.

Resumen

El flujo de trabajo que hace útil a Nano Banana para el comercio electrónico no es un único prompt mágico —es el ciclo de anclaje y recolocación: gasta $0.021 en una buena imagen de producto de nano-banana, y luego deja que Nano-Banana-2 lleve ese producto exacto (y ese rostro exacto) a través de cada escenario que necesite tu tienda. Ejecutamos el mismo ciclo con un modelo diferente en Imágenes de producto de comercio electrónico con gpt-image-2: flujo de trabajo por lotes en hiapi, por si quieres comparar salidas antes de comprometerte.

Para probar este ciclo tú mismo, obtén una clave de API, comienza con un SKU y ejecuta el script por lotes de arriba —la página del modelo Nano Banana tiene un playground en vivo y ejemplos listos para copiar y pegar que producen tu primera imagen de anclaje en menos de un minuto.