API de fotografía de producto: de una foto a la tienda

Una foto ordinaria de un producto puede ser suficiente para un conjunto limitado de imágenes frontales o de tres cuartos para la tienda, siempre que la API se le pida que cambie el conjunto, no que reinvente el producto. El flujo de trabajo práctico es simple: anota los detalles que no pueden cambiar, genera un candidato a bajo costo de 1K, recházalo según una lista de verificación fija, e incrementa la calidad o cambia modelos solo para una falla nombrada.

Esa última parte importa. Una llamada a un modelo puede terminar exitosamente y aún darte una botella con una tapa diferente, un logo suavizado, o una sombra que hace que el artículo flote. El número que vale la pena rastrear por lo tanto no es el precio de generación anunciado. Es el costo por imagen aprobada, incluyendo cada candidato completado que rechazaste.

Las tarifas en esta guía se verificaron el 3 de septiembre de 2026. Pueden cambiar, así que lee la página del modelo en vivo antes de convertirlas en una cotización de cliente o un límite de presupuesto duro.

TL;DR

• Comienza con una foto de producto que posees, mostrando un artículo sin obstrucciones desde el ángulo que pretendes vender.
• Escribe un contrato de identidad para la forma, proporciones, material, cortes de color, hardware, y marcas de etiqueta existentes. Permite que la escena cambie; no permitas que esos detalles cambien.
• El primer paso de menor costo aquí es Nano Banana 2 Lite a 15 créditos, o $0.015, por una imagen completada de 1K cuando se verificó el 3 de septiembre de 2026.^[1]
• Usa un candidato para validar el prompt. No ordenes un lote antes de que el producto sobreviva la revisión.
• Lee el usage.credits resuelto de cada tarea terminal. Divide los créditos totales cargados para intentos completados por el número que una persona aprueba.
• Mantén precios exactos, dosificación, ingredientes, marcas de certificación, y copia legal fuera de los píxeles generados. Preserva o compone el trabajo verificado.

Una foto de producto no está lista para la tienda solo porque se vea pulida

¿Pueden los usuarios subir una foto sencilla de un producto y obtener un resultado limpio para comercio electrónico, sin cambios de forma, texto de etiqueta dañado, iluminación artificial ni resultados inconsistentes? El coste importa porque cada resultado rechazado puede exigir otra generación.

Esa es una mejor definición del problema que "haz esta foto profesional." Un activo listo para la tienda tiene que pasar verificaciones observables:

Una imagen hermosa puede fallar esta tabla. Conversamente, un barrido blanco moderado que preserva cada hecho del producto puede ser el activo más valioso.

Elige un modelo por la falla que necesitas resolver

No existe un modelo universal de "mejor fotografía de producto." Comienza con la ruta menos costosa que pueda expresar la edición, luego muévete solo cuando la revisión te diga por qué la primera ruta es insuficiente.

Estas son tarifas actuales de reAPI, no precios de lista de proveedores ascendentes. Nano Banana 2 Lite devuelve una imagen de 1K y acepta hasta diez referencias de imagen públicas. GPT Image 2 ofrece niveles 1K, 2K y 4K. Seedream 5.0 Pro ofrece 1K básico y salida 2K alta, con hasta diez referencias. Nano Banana Pro también alcanza 4K; su precio resuelto de 4K fue $0.033, o 33 créditos, en la misma fecha.^[1][2][3][4]

Las etiquetas de etapa son recomendaciones de flujo de trabajo, no clasificaciones de proveedores. ByteDance posiciona Seedream 5.0 Pro alrededor de coherencia estructural, control de material e iluminación, fusión multi-imagen, y edición orientada a la producción; la foto fuente y tu prueba de aceptación aún deciden si esas capacidades ayudan a este producto particular.^[8]

La resolución no es una herramienta de reparación para geometría incorrecta. Si el borrador de 1K cambia la tapa, una re-ejecución de 4K puede darte una tapa incorrecta más nítida. Primero repara la instrucción de identidad o añade una referencia útil. Aumenta la resolución solo después de que la composición y el producto hayan aprobado.

Para compensaciones de capacidad más amplias, usa la comparación completa de GPT Image 2 versus Nano Banana Pro o la comparación de Seedream 5.0 Pro versus GPT Image 2. El resto de esta guía se queda con el trabajo de foto de producto.

Prepara la foto fuente antes de gastar un crédito

Confirma que eres propietario de la fuente o tienes permiso para transformarla antes de presentarla. No asumas que un listado de mercado, otro catálogo, o una carga de cliente está autorizado para un nuevo activo comercial; verifica la licencia aplicable, los términos, y el consentimiento del cliente.

La fuente no necesita un fondo de estudio. Necesita hacer el producto legible:

• muestra un artículo completo, incluyendo su base y parte superior;
• usa el mismo ángulo amplio que deseas en el resultado;
• mantén dedos, cinta, brillo, y accesorios lejos de bordes importantes;
• evita negros aplastados e iluminaciones reventadas que oculten el material;
• haz la tapa, asa, bomba, sujetador, y límites de color fáciles de inspeccionar;
• suministra otro ángulo propio cuando el resultado solicitado expone un lado que la primera foto no muestra.

Una foto no es un modelo 3D. No puede probar qué está impreso en un panel posterior oculto o cómo está formado un mecanismo invisible. Cuando la evidencia está ausente, ya sea captura otra referencia o mantén esa superficie fuera de la vista.

La API acepta medios como URLs públicas HTTP(S). Las cadenas Base64 y URLs data: se rechazan, así que carga la fuente a tu propio R2, S3, o almacenamiento de objetos equivalente primero.^[1]

Escribe un contrato de identidad de producto

Antes de escribir el prompt visual, convierte la fuente en un breve registro de inspección. Esto no es prosa para el modelo aún; es la especificación que tanto el prompt como el revisor usarán.

{
  "product": "250 ml skincare bottle",
  "must_keep": [
    "exactly one bottle",
    "tall rounded-rectangle silhouette",
    "short matte-white pump",
    "cobalt band at the lower quarter",
    "warm-white body with a satin finish",
    "front label position and all existing marks",
    "height-to-width ratio"
  ],
  "may_change": [
    "background",
    "surface",
    "lighting direction",
    "contact shadow",
    "crop room"
  ],
  "must_not_create": [
    "new words or logos",
    "price or discount badge",
    "ingredients or certification claim",
    "extra bottle, cap, pump, or packaging"
  ]
}

"Mantenlo consistente" no le da al revisor nada a lo que apuntar. "La banda de cobalto permanece en el cuarto inferior" sí.

Construye el primer prompt de fotografía de producto

Pon la identidad no negociable primero, luego di qué puede cambiar, luego describe la toma. Los modelos tienden a seguir un límite concreto mejor que una larga lista de adjetivos de fotografía.

Use Image 1 as the exact product identity.

Keep exactly one product. Preserve its silhouette, dimensions, pump position,
warm-white satin material, cobalt color boundary, surface texture, and every
existing label mark. Do not redesign, relabel, remove, or add branding.

Change only the setting: place the product centered on a warm-white seamless
studio sweep. Use a large soft key light from the upper left, even front detail,
and a natural contact shadow directly below the bottle. Keep the whole product
visible with at least 10% crop room on every side.

No hands, people, props, boxes, extra products, added text, badges, dramatic
reflections, clipped edges, or floating object.

El prompt no le pide al modelo que mejore la etiqueta. Si la tipografía de etiqueta es comercialmente importante, la "mejora" es una invitación a redibujarlo. Preserva la placa original o añade trabajo verificado después de la generación.

Presenta tu primer trabajo de API de fotografía de producto

Crea una clave de API de medios, reemplaza la URL de ejemplo con tu imagen fuente pública, y presenta una tarea de Nano Banana 2 Lite. Esta es una solicitud pagada; es deliberadamente un candidato en lugar de un lote.

curl https://reapi.ai/api/v1/images/generations \
  -H "Authorization: Bearer $REAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nano-banana-2-lite",
    "prompt": "Use Image 1 as the exact product identity. Keep exactly one product. Preserve its silhouette, dimensions, pump position, material, color boundaries, surface texture, and every existing label mark. Do not redesign, relabel, remove, or add branding. Change only the setting: center it on a warm-white seamless studio sweep with a soft key light from upper left and a natural contact shadow. Keep the whole product visible with at least 10% crop room. No hands, people, props, extra products, added text, badges, clipped edges, or floating object.",
    "image_urls": ["https://assets.example.com/my-product.jpg"],
    "aspect_ratio": "1:1"
  }'

La respuesta contiene un id y status: "processing". Guarda el ID. Luego sondea el endpoint de tarea cada dos o tres segundos hasta que alcance completed o failed:

TASK_ID="task_replace_me"

curl "https://reapi.ai/api/v1/tasks/$TASK_ID" \
  -H "Authorization: Bearer $REAPI_API_KEY"

El sondeo no consume créditos. Una tarea de imagen completada devuelve el archivo en output.image_urls y el cargo resuelto en usage.credits.^[5]

No repitas ciegamente el POST cuando un cliente pierde su conexión antes de leer la respuesta. La primera solicitud puede ya haber creado una tarea pagada. Registra la respuesta y el ID de tarea tan pronto como lleguen; reinténtalo GET de manera segura, pero toma una decisión deliberada antes de crear otra generación.

Un ejecutor completo de Node.js con sondeo acotado

El siguiente script funciona en Node.js 20 o posterior sin un SDK. Soporta las cuatro formas de solicitud de 1K utilizadas en esta guía, presenta exactamente una vez, usa un plazo de sondeo local de cinco minutos, imprime los créditos resueltos, y copia un archivo exitoso al directorio actual.

import { writeFile } from 'node:fs/promises';

const apiKey = process.env.REAPI_API_KEY;
const sourceUrl = process.env.SOURCE_IMAGE_URL;
const model = process.env.IMAGE_MODEL || 'nano-banana-2-lite';

if (!apiKey || !sourceUrl) {
  throw new Error('Set REAPI_API_KEY and SOURCE_IMAGE_URL first.');
}

const prompt = `Use Image 1 as the exact product identity.
Keep exactly one product. Preserve its silhouette, proportions, hardware,
material, color boundaries, surface texture, and every existing label mark.
Do not redesign, relabel, remove, or add branding.
Change only the setting: center it on a warm-white seamless studio sweep with
a soft key light from upper left and a natural contact shadow. Keep the whole
product visible with at least 10% crop room. No hands, people, props, added
text, badges, extra products, clipped edges, or floating object.`;

function requestBody(selectedModel) {
  const common = {
    model: selectedModel,
    prompt,
    image_urls: [sourceUrl],
  };

  if (selectedModel === 'nano-banana-2-lite') {
    return { ...common, aspect_ratio: '1:1' };
  }
  if (selectedModel === 'gpt-image-2') {
    return { ...common, size: '1:1', resolution: '1k' };
  }
  if (selectedModel === 'doubao-seedream-5-0-pro') {
    return { ...common, aspect_ratio: '1:1', quality: 'basic' };
  }
  if (selectedModel === 'gemini-3-pro-image-preview') {
    return { ...common, size: '1:1', resolution: '1k' };
  }
  throw new Error(`Unsupported IMAGE_MODEL: ${selectedModel}`);
}

const headers = {
  Authorization: `Bearer ${apiKey}`,
  'Content-Type': 'application/json',
};

async function readJson(response) {
  const body = await response.json();
  if (!response.ok) {
    const message = body.error?.message || JSON.stringify(body);
    throw new Error(`HTTP ${response.status}: ${message}`);
  }
  return body;
}

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function getTask(taskId) {
  for (let attempt = 0; attempt < 4; attempt += 1) {
    let response;
    try {
      response = await fetch(`https://reapi.ai/api/v1/tasks/${taskId}`, {
        headers: { Authorization: `Bearer ${apiKey}` },
        signal: AbortSignal.timeout(15_000),
      });
    } catch (error) {
      if (attempt === 3) throw error;
      await sleep(1000 * 2 ** attempt);
      continue;
    }

    if (response.status === 429) {
      const seconds = Number(response.headers.get('retry-after'));
      await response.body?.cancel();
      await sleep(Number.isFinite(seconds) ? seconds * 1000 : 5000);
      continue;
    }

    if ([502, 503, 504].includes(response.status)) {
      await response.body?.cancel();
      await sleep(1000 * 2 ** attempt);
      continue;
    }

    return readJson(response);
  }

  throw new Error(`Task ${taskId} could not be read after transient errors`);
}

// Submit once. If this connection fails ambiguously, reconcile before
// re-running the script: the server may already have accepted the task.
const submission = await readJson(
  await fetch('https://reapi.ai/api/v1/images/generations', {
    method: 'POST',
    headers,
    body: JSON.stringify(requestBody(model)),
    signal: AbortSignal.timeout(30_000),
  }),
);

console.log(`submitted ${submission.id}`);

const deadline = Date.now() + 5 * 60 * 1000;
let task;

while (Date.now() < deadline) {
  await sleep(3000);
  task = await getTask(submission.id);
  if (task.status === 'completed' || task.status === 'failed') break;
}

if (!task || task.status === 'processing') {
  throw new Error(
    `Local polling deadline reached. Resume GET for ${submission.id}; do not POST again.`,
  );
}

console.log(`status=${task.status} credits=${task.usage.credits}`);

if (task.status === 'failed') {
  const credits = task.usage?.credits ?? 'unknown';
  throw new Error(
    `${task.error?.code || 'task_failed'}: ${task.error?.message || 'unknown error'}; task=${task.id}; settled_credits=${credits}`,
  );
}

const outputUrl = task.output?.image_urls?.[0];
if (!outputUrl) throw new Error('Task completed without an image URL.');

const imageResponse = await fetch(outputUrl, {
  signal: AbortSignal.timeout(30_000),
});
if (!imageResponse.ok) {
  throw new Error(`Image download failed: HTTP ${imageResponse.status}`);
}

const contentType = (imageResponse.headers.get('content-type') || '')
  .split(';')[0]
  .trim()
  .toLowerCase();
const extensionByType = {
  'image/jpeg': 'jpg',
  'image/png': 'png',
  'image/webp': 'webp',
};
const extension = extensionByType[contentType];
if (!extension) throw new Error(`Unexpected output type: ${contentType}`);
const outputPath = `product-candidate.${extension}`;

await writeFile(outputPath, Buffer.from(await imageResponse.arrayBuffer()));
console.log(`saved ${outputPath} from ${outputUrl}`);

Ejecútalo así:

export REAPI_API_KEY="rk_live_replace_me"
export SOURCE_IMAGE_URL="https://assets.example.com/my-product.jpg"
export IMAGE_MODEL="nano-banana-2-lite"
node product-photo.mjs

Para probar GPT Image 2, Seedream 5.0 Pro, o Nano Banana Pro después de la revisión, cambia solo IMAGE_MODEL. El constructor de solicitud suministra el campo de tamaño correcto para cada modelo.

Lo que devolvió una prueba en vivo de 15 créditos

El 3 de septiembre de 2026, enviamos un PNG de 2,048 × 1,152 alojado en reAPI a través de la solicitud exacta de Nano Banana 2 Lite anterior, con una relación de salida cuadrada. La tarea task_01a065bb951c735fab44b38c778e069e se completó, devolvió un JPEG de 1,024 × 1,024, y se resolvió en 15 créditos ($0.015). La URL de la imagen fue descargable sin autenticación cuando la verificamos.

El resultado hizo lo que se suponía que el primer paso debía probar: mantuvo una taza, mostró el contorno completo y la abertura del asa, eliminó los libros y plantas, y colocó el producto en un barrido neutro con una sombra de contacto. También cambió pequeñas motas de esmalte y reflejos. Eso lo convierte en un candidato de diseño útil, no prueba de que un SKU único hecho a mano permaneciera pixel-idéntico. Una ejecución valida la forma de solicitud, forma de salida, y cargo; no establece latencia, tasa de aceptación, o ganador de modelo.^[1]

Revisa el primer resultado al 100% de tamaño

No decidas desde una miniatura. Abre la fuente y candidato lado a lado, amplía al 100%, y llena un registro como este:

{
  "task_id": "task_replace_me",
  "decision": "reject",
  "passed": [
    "one product",
    "complete crop",
    "background",
    "contact shadow"
  ],
  "failed": [
    "pump became taller",
    "lower cobalt band moved upward"
  ],
  "usage_credits": 15,
  "reviewer": "initials",
  "prompt_revision": 1
}

Verifica el contorno primero. Luego compara hitos fijos: altura de tapa, abertura de asa, esquinas, costuras, conteo de botones, límites de color, posición de etiqueta, y acabado de superficie. Lee cada palabra visible. Finalmente inspecciona el recorte y la sombra.

Este orden es intencional. Un configuración de luz sabrosa no debería convencerte de aprobar un producto diferente.

Reintentar una condición fallida, no todo el resumen

"Intenta de nuevo" no te enseña nada. Lleva las partes aprobadas hacia adelante y cambia una instrucción vinculada a la falla.

Dale a un modelo casi correcto un reintento dirigido. Si la misma condición de identidad falla de nuevo, cambia el método: proporciona una referencia mejor, usa una edición localizada, o mantén los píxeles del producto original y reconstruye solo el fondo. La guía de precios de API de eliminación de fondo muestra cómo fijar el precio de esa ruta determinista.

Calcula qué costó realmente una imagen aprobada

Un crédito es $0.001. La fórmula útil es:

costo por imagen aprobada =
  suma de créditos resueltos para intentos creativos completados × $0.001
  ────────────────────────────────────────────────────────────────────────
                     número de imágenes aprobadas

Supongamos que tres tareas de Nano Banana 2 Lite se completan en 15 créditos cada una. Rechazas dos por desvío de producto y apruebas una:

(15 + 15 + 15) × $0.001 / 1 imagen aprobada = $0.045

El precio unitario de API es todavía $0.015. Tu costo de imagen aceptada es $0.045. Ambos números son verdaderos; responden preguntas diferentes.

Los fallos de proveedor normalmente se resuelven a créditos cero después de que la reserva se reembolsa. Las imágenes completadas que rechazas creativamente permanecen pagadas. Una verificación de seguridad post-generación específica del modelo también puede retener un cargo incluso cuando oculta la salida, así que usa status junto con usage.credits en lugar de asumir que cada tarea fallida costó cero.^[5]

Si quieres una pequeña prueba de humo entre modelos, un intento de 1K cada uno de Nano Banana 2 Lite, GPT Image 2, y Seedream 5.0 Pro actualmente presupuesta:

15 + 30 + 32 = 77 créditos = $0.077

Ese es un presupuesto de planificación no ejecutado, no una prueba medida, tasa de aceptación, o clasificación de modelo. Una salida por modelo no apoyaría ninguna de esas afirmaciones. Un primer movimiento más barato y más útil es todavía el único candidato de diseño de 15 créditos, seguido por una decisión específica de falla.

Pon el flujo de trabajo en producción sin perder el rastro de auditoría

Para cada generación, persiste:

• un hash o ID duradero para el activo fuente;
• el ID de modelo exacto, nivel de salida, prompt, y revisión de prompt;
• el tiempo de presentación e ID de tarea devuelto;
• status, usage.credits, y cualquier código de error terminal;
• la URL devuelta y la ubicación de tu copia archivada;
• estado de aprobación, revisor, y una breve razón de rechazo.

Mantén presentación y sondeo como trabajos separados. Un trabajador puede presentar una vez, almacenar el ID de tarea, y dejar que otro trabajador reanude solicitudes GET después de un reinicio. Establece un plazo de sondeo local, pero no confundas ese plazo con un fallo de API: si tu proceso deja de esperar, reanuda la misma tarea más tarde.

Archiva archivos aprobados al almacenamiento que controlas. El contrato de Tareas no promete que el ciclo de vida CDN de un despliegue coincidirá con la vida útil de tu catálogo, y una página de producto no debería depender de un registro de generación temporal.^[5]

Para un lote sin código después de que el primer prompt haya pasado, el flujo de trabajo de cinco imágenes de anuncio de producto en n8n muestra la misma estructura de presentación y sondeo. Si más tarde quieres movimiento, lleva la foto fija aprobada y el contrato de identidad al flujo de trabajo de video de foto de producto única.

Cuando la generación es la herramienta incorrecta

Mantén los píxeles del producto original y cambia solo el lienzo circundante cuando:

• la etiqueta exacta, número de serie, o marca regulatoria debe permanecer legible;
• la geometría debe ser pixel-idéntica en un catálogo grande;
• el producto es transparente, reflectivo, o cubierto en texto repetido fino;
• el destino utiliza una plantilla de fondo blanco fijo;
• un color incorrecto o detalle de embalaje podría crear una queja material del cliente.

En esos casos, elimina el fondo, limpia la máscara, coloca el recorte en una superficie conocida, y crea la sombra con una plantilla de diseño determinista. Una API generativa aún puede hacer una placa de fondo, pero no necesita redibujar el producto.

FAQ

¿Cuál es la ruta de API más barata para probar primero?

Entre las rutas de esta guía, Nano Banana 2 Lite fue $0.015, o 15 créditos, por una imagen completada de 1K el 3 de septiembre de 2026. Verifica la página del modelo en vivo antes de presupuestar porque las tarifas pueden cambiar.

¿Puede una foto preservar la parte posterior y los lados de un producto?

No. Puede guiar forma visible, material, y colocación de etiqueta. No puede reconstruir de manera confiable hechos que la fuente no muestra. Suministra otro ángulo poseído o evita exponer la superficie invisible.

¿Debería pedirle al modelo que reescriba una etiqueta borrosa?

No para la verdad de producción. Usa trabajo de etiqueta verificado o la placa de producto original. Un nuevo ingrediente plausible, dosificación, certificación, o garantía sigue siendo información falsa.

¿Debería generar a 2K o 4K inmediatamente?

Comienza en 1K para validar identidad, composición, y recorte. Muévete solo después de que la imagen pase esas verificaciones y el canal de entrega genuinamente necesite más píxeles. OpenAI y Google ambos documentan múltiples tamaños de salida para sus modelos de imagen actuales, mientras que la disponibilidad específica del modelo y la facturación difieren.^[6][7]

¿Qué relación de aspecto debería usar para listados de productos?

Usa la relación requerida por el destino. Para una prueba entre modelos, 1:1 es un ajuste compartido seguro. La solicitud pública actual de Seedream 5.0 Pro acepta 1:1, 4:3, 3:4, 16:9, 9:16, 2:3, y 3:2, pero no 4:5.^[3]

¿Puede la API devolver una imagen de producto transparente?

Depende del modelo y superficie de solicitud. Seedream 5.0 Pro expone una opción de fondo transparente solo para una imagen de referencia que ya tiene un canal alfa, y no puede combinarse con descomposición de capas. Si tu foto inicial tiene un fondo normal, un flujo de trabajo de eliminación dedicado es el primer paso más claro.^[3]

¿Se cobran las tareas fallidas?

Los fallos de proveedor y tiempos agotados normalmente se reembolsan, pero la respuesta definitiva es el usage.credits de la tarea terminal. Algunas decisiones de seguridad post-generación pueden retener un cargo específico del modelo incluso con status: "failed". Nunca calcules la factura desde el estado solo.^[5]

¿Puedo automatizar la aprobación?

Puedes automatizar verificaciones mecánicas como dimensiones, decodificación de archivo, alfa, y conteo de productos. Geometría, precisión de etiqueta fina, color, y seguridad de afirmación aún necesitan una puerta humana a menos que tengas un sistema de comparación específico del producto validado. La automatización debería enrutar imágenes inciertas a revisión, no publicarlas silenciosamente.

Comienza en 1K y escalona solo para una falla nombrada

Un flujo de trabajo útil de API de fotografía de producto es conservador. Comienza con la fuente como evidencia, congela la identidad del producto, y se queda en 1K hasta que el producto en sí sea correcto. Registra rechazos completados, porque esos son parte del costo real. Y sabe cuándo un recorte más una plantilla es más seguro que otra generación imaginativa.

Así es como una foto ordinaria se convierte en imágenes listas para la tienda sin tratar un render que se vea bien como prueba de que el producto sobrevivió.

References

1. reAPI. Nano Banana 2 Lite API: live pricing, request schema, and task lifecycle. Retrieved September 3, 2026 from the Nano Banana 2 Lite model page.
2. reAPI. GPT Image 2 API: live pricing and request schema. Retrieved September 3, 2026 from the GPT Image 2 model page.
3. reAPI. Seedream 5.0 Pro API reference. Retrieved September 3, 2026 from the Seedream 5.0 Pro documentation.
4. reAPI. Gemini 3 Pro Image Preview API: live pricing and request schema. Retrieved September 3, 2026 from the Nano Banana Pro model page.
5. reAPI. Tasks API: states, usage, polling, output, and refund semantics. Retrieved September 3, 2026 from the Tasks API reference.
6. OpenAI. Image generation guide and GPT Image 2 model reference. Retrieved September 3, 2026 from the OpenAI developer documentation.
7. Google. Gemini API image generation guide. Retrieved September 3, 2026 from the Google AI for Developers documentation.
8. ByteDance Seed. Beyond Generation, It Understands Design: Introducing Seedream 5.0 Pro. Retrieved September 3, 2026 from the Seed product blog.

Further reading

• Product-image automation in n8n
• Background removal API pricing
• Turn an approved product still into a video ad
• Nano Banana Pro versus Nano Banana 2