Gerar imagens de produtos de e-commerce com Nano-Banana via API hiapi

A fotografia de produto é o trabalho de imagem mais repetitivo no e-commerce: o mesmo produto, fotografado repetidamente — imagem de produto com fundo branco, imagem em cena de lifestyle, imagem de embalagem, imagem com modelo, imagem com variação sazonal. A parte difícil nunca foi gerar uma imagem bonita. Difícil é gerar o mesmo produto em cada imagem, para que sua página de detalhes do produto não pareça estar vendendo cinco frascos ligeiramente diferentes.

Este guia mostra uma solução viável na API Nano Banana da hiapi, usando dois modelos da mesma família:

• nano-banana — geração de imagem por texto rápida e barata, $0,021 por imagem. Use para criar sua imagem de ancoragem.
• Nano-Banana-2 — aceita imagens de referência via o array image_input ($0,036 por imagem 1K). Use para reposicionar a imagem de ancoragem em todas as outras cenas, mantendo o produto — e até modelos reais — perfeitamente consistentes.

Cada imagem abaixo foi gerada no momento da redação deste artigo, com o prompt exato impresso ao lado. O produto é uma marca fictícia criada para este artigo ("LUMA").

TL;DR

1. Gere uma imagem de ancoragem limpa com fundo branco usando nano-banana ($0,021).
2. Hospede-a em uma URL pública (seu S3/R2/CDN — qualquer lugar serve).
3. Passe essa URL como image_input para Nano-Banana-2 e descreva cada nova cena. O frasco, o rótulo e a tipografia serão preservados intactos.
4. Para imagens com modelo, use o mesmo truque com pessoas: gere uma imagem de modelo e depois a referencie para manter o mesmo rosto em toda a campanha.
5. Processe todo o fluxo em lote com o endpoint assíncrono /v1/tasks — o código está no final.

Passo 1 — Imagem de ancoragem (nano-banana, $0,021)

Comece pela imagem de listagem de marketplace: produto centralizado, fundo branco puro. Esta é a imagem que todas as imagens subsequentes herdarão, então capriche 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

Um detalhe de schema que evita erros 400: nano-banana suporta apenas geração de imagem por texto. Sua entrada aceita apenas três campos — prompt, aspect_ratio e output_format. Se você enviar resolution ou qualquer campo de imagem, a API rejeita a requisição com additional properties not allowed. Imagens de referência são trabalho do próximo modelo.

Passo 2 — O mesmo frasco, nova cena (Nano-Banana-2 + image_input)

Faça upload da imagem de ancoragem em algum local público e passe sua URL para Nano-Banana-2. O campo image_input aceita um array de URLs de imagem (não o conteúdo do arquivo), e o prompt descreve a nova cena. A frase-chave que faz funcionar é: "este frasco exato, inalterado."

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

Compare o rótulo com a imagem de ancoragem: mesmo logotipo tipográfico, mesma linha dourada, mesmo padrão da tampa. Essa é a diferença entre a "imagem de produto de IA" que o cliente sinaliza e uma imagem que parece uma fotografia real.

O mesmo vale para a embalagem — descreva a caixa como uma extensão da imagem de referência:

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 — Imagem com modelo de rosto consistente

Equipes de e-commerce refotografam com o mesmo modelo por uma razão: uma campanha em que cada foto mostra uma pessoa diferente parece banco de imagens. A técnica de referência também funciona com pessoas. Primeiro, gere uma imagem de modelo que inclua seu produto (esta usa o frasco de ancoragem como referência):

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

Depois use essa imagem como referência para a próxima cena e peça "a mesma mulher":

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

Mesmo rosto, mesmo cabelo, mesmo suéter, nova cena. Encadeie quantas vezes sua campanha precisar: cada saída aceita se torna a referência do próximo shot.

A API de ponta a ponta

Tudo roda pelo endpoint unificado de tarefas assíncronas da hiapi. Crie a tarefa, faça polling, baixe a saída. A imagem de ancoragem em 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"}

A chamada de reposicionamento difere apenas no nome do modelo e no 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"
    }
  }'

Faça polling de GET /v1/tasks/{taskId} até data.status ser success (ou fail), depois baixe data.output[0].url. Duas observações de produção:

• As URLs de saída são temporárias — a resposta traz um timestamp expireAt. Baixe os bytes imediatamente e coloque-os no seu próprio armazenamento; não faça hotlink. (Mais sobre esse modo de falha: URL de saída do hiapi expirou: baixe antes do vencimento.)
• Para um pipeline real, passe callback.url no nível superior da requisição de criação em vez de fazer polling — a hiapi chamará seu endpoint quando a tarefa atingir o estado final.

Cada execução por trás deste artigo foi concluída em bem menos de dois minutos.

Script em lote: uma imagem de ancoragem, o catálogo inteiro

O padrão escala linearmente: para cada SKU, uma imagem de ancoragem + N reposicionamentos. Segue uma versão compacta e executável:

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

As tarefas são criadas antecipadamente e geradas concorrentemente no lado da hiapi; depois o loop as coleta em sequência. Adicione callback.url ao payload de criação e, assim que tiver um receptor de webhook, remova completamente o wait().

Cálculo de custo para um catálogo real

Os preços abaixo vêm da página de preços da hiapi ao vivo no momento da redação — considere essa página a fonte da verdade:

Modelo	Papel neste fluxo de trabalho	Preço
nano-banana	Imagem de ancoragem, rascunho rápido (apenas geração de imagem por texto)	$0,021 / imagem
Nano-Banana-2	Reposicionamento baseado em referência (image_input)	$0,036 por imagem 1K, $0,086 por imagem 4K
Nano-Banana-Pro	Edição de máxima fidelidade, até 8 imagens de referência	$0,057 por imagem 1K

Um catálogo de 40 SKUs, com uma imagem de ancoragem e quatro shots reposicionados por SKU:

• 40 imagens de ancoragem × $0,021 = $0,84
• 160 reposicionamentos × $0,036 = $5,76
• Total: $6,60 por um catálogo de 200 imagens visualmente consistentes — sem diária de estúdio, sem refotografia quando uma cena precisa mudar.

Duas dicas práticas para a loja. Primeiro, a saída é entregue a você como arquivos de imagem comuns — você os hospeda no seu próprio CDN, então nada na stack vincula suas listagens de produto a um visualizador de terceiros. Segundo, as imagens de "modelo" geradas são sintéticas: a mulher acima não existe, o que contorna a logística de liberação de imagem de modelo — mas antes de promover imagens geradas para uma vitrine em produção, verifique os termos atuais do provedor subjacente (Google) e a política de imagens de IA do seu mercado.

Resumo

O fluxo de trabalho que torna o Nano Banana útil para e-commerce não é um único prompt mágico — é o ciclo de ancoragem e reposicionamento: gaste $0,021 com nano-banana para obter uma boa imagem de produto e depois deixe o Nano-Banana-2 levar esse produto exato (e esse rosto exato) por todas as cenas que sua loja precisa. Rodamos o mesmo ciclo com um modelo diferente em gpt-image-2 para imagens de produto de e-commerce: fluxo em lote na hiapi, caso queira comparar as saídas antes de se comprometer.

Para testar esse ciclo você mesmo, obtenha uma chave de API, comece com um SKU e rode o script em lote acima — a página do modelo Nano Banana tem um playground ao vivo e exemplos prontos para copiar e colar que entregam sua primeira imagem de ancoragem em menos de um minuto.