Inicio rápido de la API de PixMind: genera imágenes con Node.js

Que se acepte una solicitud de generación de imágenes no significa que la imagen ya esté lista. Tu aplicación debe conservar el ID de tarea, consultar esa misma tarea y gestionar las solicitudes fallidas o interrumpidas sin iniciar otro trabajo por accidente.

En este tutorial crearás un pequeño cliente de Node.js que ejecuta esa secuencia en el servidor. Incluye dos comandos independientes, submit y resume: uno crea una tarea y el otro solo consulta una tarea existente. Empieza por los ID de modelos compatibles con la API, no por un nombre de modelo copiado de un anuncio en la página de inicio.

El tutorial aborda la generación de imágenes a partir de texto. No carga archivos de referencia, no implementa una interfaz de navegador ni evalúa la calidad de los modelos. La validación combina 29 pruebas locales con respuestas simuladas y una sola tarea controlada de generación de imágenes en producción, realizada el 4 de septiembre de 2026. Esa tarea devolvió una imagen y registró un cargo de API de 120 puntos. Es una comprobación de integración realizada en una fecha concreta, no una prueba comparativa de velocidad, un precio universal ni una garantía de disponibilidad para otra cuenta.

La portada es una captura del catálogo de modelos tomada el 4 de septiembre de 2026. Considérala una ilustración de ese momento, no una cotización vigente ni una garantía de disponibilidad.

Puntos clave

• Mantén la clave de API en tu servidor, fuera del código distribuido al navegador y de los repositorios públicos.
• Para una tarea de imagen, lee el valor numérico de data.taskId en la respuesta de aceptación y consérvalo para las consultas posteriores.
• Consulta periódicamente la tarea guardada hasta que llegue a ready o failed. Lee las URL de las imágenes en data.images solo después de que se complete correctamente.
• Que el cliente agote su tiempo de espera no demuestra que la tarea remota haya fallado o se haya cancelado. Reanuda las consultas si tienes un ID de tarea; no repitas la solicitud de creación sin comprobar antes qué ocurrió.

En esta guía

• Antes de empezar
• Elige un modelo y configura tu clave de API
• Envía una solicitud con cURL
• Consulta la tarea y lee las URL de las imágenes
• Ejemplo completo de Node.js
• Gestiona los errores
• Diferencias para video y chat
• Verifica tu integración

Antes de empezar

Usa una terminal privada o un entorno de servidor con Node.js, una clave de API y una cuenta configurada para la facturación de la API. El ejemplo que acompaña al tutorial utiliza fetch integrado y módulos de JavaScript, sin instalar paquetes de terceros. La documentación de las API globales de Node.js describe fetch y AbortSignal.timeout, que el cliente utiliza para limitar la duración de cada solicitud. El entorno de validación local es Windows con Node.js v22.22.1; este dato documenta el entorno de prueba y no implica que se hayan probado todas las demás versiones.

Necesitas saber editar un archivo, definir una variable de entorno y leer JSON. Comprueba la versión del entorno de ejecución que tienes instalada antes de continuar:

node --version

El comando debe mostrar la versión instalada. No contacta con la API de generación. Guarda el cliente completo de la sección posterior como examples/pixmind-image.mjs dentro de una carpeta de trabajo y ejecuta sus comandos desde esa carpeta.

Elige un prompt de prueba inocuo, sin datos de clientes ni material confidencial. Este tutorial utiliza una taza de café de cerámica sobre un fondo de estudio, por lo que no necesita cargar archivos de referencia. Revisa el precio actual del modelo seleccionado en la API antes de enviar la solicitud. No debes dar por hecho que los créditos de Studio, las suscripciones y la facturación de la API sean intercambiables; el catálogo de modelos explica la oferta de API aplicable.

Si solo quieres crear una imagen de forma interactiva, la guía de Image Agent describe ese proceso. El cliente de este tutorial está pensado para una aplicación que proporciona explícitamente un ID de modelo y procesa la respuesta por su cuenta.

Elige un modelo y configura tu clave de API

Utiliza un ID de modelo compatible con la API y parámetros admitidos por ese modelo. El ejemplo selecciona nano-banana-pro, con aspectRatio: "1:1" y resolution: "1K", de acuerdo con la solicitud de imagen del inicio rápido de la API. Una consulta autenticada a GET /models y la prueba en producción confirmaron esa combinación para la cuenta de prueba el 4 de septiembre de 2026. Vuelve a comprobar la disponibilidad y la compatibilidad de los parámetros para tu propia cuenta antes de ejecutar una solicitud real. Cambiar solo el identificador del modelo no garantiza que el resto de la solicitud siga siendo válido.

Crea una clave en la consola de la API y proporciónala al proceso del servidor como PIXMIND_API_KEY. Utiliza tu sistema privado de gestión de secretos, si dispones de uno. Los siguientes ejemplos muestran la sintaxis de variables de entorno con un valor de ejemplo, no con una credencial válida.

En PowerShell:

$env:PIXMIND_API_KEY = "REPLACE_WITH_YOUR_PRIVATE_API_KEY"
$env:PIXMIND_MODEL = "nano-banana-pro"
$env:PIXMIND_PROMPT = "A ceramic coffee cup on a plain studio background, soft side lighting, no text"

En Bash:

export PIXMIND_API_KEY="REPLACE_WITH_YOUR_PRIVATE_API_KEY"
export PIXMIND_MODEL="nano-banana-pro"
export PIXMIND_PROMPT="A ceramic coffee cup on a plain studio background, soft side lighting, no text"

Estas asignaciones configuran la sesión actual de la terminal y los procesos iniciados desde ella. No crean una tarea. Protege el historial de la terminal y las grabaciones cuando introduzcas un secreto real, y nunca lo guardes en el sistema de control de versiones. Sigue la guía de autenticación para utilizar claves distintas en desarrollo y producción, y para rotarlas si quedan expuestas.

La URL base de este tutorial es:

https://aihub-admin.aimix.pro/api-platform/v1

Añade /generations o /tasks/{taskId} a esa base. No añadas un segundo /v1. Puedes consultar los modelos mediante GET /models; el catálogo es la opción más cómoda para revisar las capacidades de cada modelo antes de elegir los parámetros.

Envía tu primera solicitud de imagen con cURL

La solicitud con cURL es una alternativa al comando submit de Node.js, no un paso de configuración que debas ejecutar primero. Ambos envían una solicitud de generación. Ejecutar los dos puede crear dos tareas facturables. Si envías la solicitud con cURL, utiliza después el comando resume de Node.js con el ID de tarea recibido.

Este ejemplo usa la sintaxis de Bash. En PowerShell, utiliza el cliente de Node.js que aparece más abajo en lugar de pegar en la terminal los caracteres de continuación de línea de Bash.

curl --connect-timeout 10 --max-time 30 \
  --request POST \
  'https://aihub-admin.aimix.pro/api-platform/v1/generations' \
  --header "Authorization: Bearer $PIXMIND_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "nano-banana-pro",
    "type": "image",
    "prompt": "A ceramic coffee cup on a plain studio background, soft side lighting, no text",
    "aspectRatio": "1:1",
    "resolution": "1K"
  }'

El prompt y los parámetros del cuerpo de esta solicitud con cURL son valores literales. Cambiar PIXMIND_PROMPT no modifica este JSON; quien lee esa variable de entorno es el cliente de Node.js. Esta distinción ayuda a separar la solicitud que quieres enviar de la configuración de la terminal que la rodea.

A continuación se muestra una respuesta de aceptación ilustrativa y abreviada. Su ID es un valor de ejemplo, no el de la prueba en producción; 12345 no es una tarea que debas consultar.

{
  "code": 1000,
  "message": "success",
  "data": {
    "id": "img_12345",
    "taskId": 12345
  }
}

Las respuestas de contenido multimedia probadas en producción incluían los datos correctos dentro de un objeto con code, message, data y timestamp; la ilustración omite la marca de tiempo y otros campos. Para este flujo, el éxito exige tanto una respuesta HTTP correcta como una respuesta válida de la aplicación. Lee data.taskId, no data.id: este último puede contener una cadena con prefijo, como img_12345, mientras que la ruta de consulta de tareas utiliza el ID numérico.

Guarda ese ID numérico de inmediato. Si la solicitud agota el tiempo de espera antes de que lo recibas, detente y comprueba qué ocurrió con el envío en los registros de tareas de tu cuenta o con ayuda del equipo de soporte. Repetir el POST no es una alternativa segura a averiguar qué sucedió.

Consulta periódicamente la tarea y lee las URL de las imágenes

Consulta la tarea existente hasta que alcance un estado final. La documentación de tareas asíncronas describe pending, processing, ready y failed. Solo los dos últimos ponen fin a este flujo de consulta periódica.

Submit once
    |
Save numeric taskId
    |
GET /tasks/{taskId} <--- wait, then query again
    |                            ^
    +--- pending / processing ---+
    |
    +--- ready  ---> read images, stop
    |
    +--- failed ---> report failure, stop

Para hacer una consulta manual en Bash, sustituye el ID de ejemplo por el tuyo:

TASK_ID="REPLACE_WITH_YOUR_NUMERIC_TASK_ID"
curl --connect-timeout 10 --max-time 30 \
  "https://aihub-admin.aimix.pro/api-platform/v1/tasks/$TASK_ID" \
  --header "Authorization: Bearer $PIXMIND_API_KEY"

En el formato actual de las respuestas de contenido multimedia, los campos que necesitas cumplen funciones diferentes:

Una respuesta ready sin URL de imágenes utilizables no es un resultado de imagen satisfactorio para tu aplicación. Informa de esa discrepancia junto con el ID de tarea para que pueda investigarse. No la sustituyas por una URL de ejemplo ni indiques que se descargó una imagen.

El cliente muestra las URL de las imágenes recibidas; no descarga ni archiva los archivos de imagen. Si tu aplicación necesita almacenamiento duradero, diséñalo como un paso independiente y confirma las condiciones aplicables de conservación y uso de los recursos. La presencia de una URL no implica una garantía de almacenamiento permanente.

Ejecuta el ejemplo completo de Node.js

Utiliza submit para crear una tarea nueva o resume para consultar una existente. Si ejecutas el script sin argumentos, muestra las instrucciones de uso y no hace ninguna llamada a la API. Este comportamiento predeterminado evita que un reinicio habitual o una revisión rápida de la interfaz de línea de comandos cree un trabajo nuevo.

Guarda el código completo que aparece a continuación como examples/pixmind-image.mjs:

import { pathToFileURL } from 'node:url';

const BASE_URL = 'https://aihub-admin.aimix.pro/api-platform/v1';
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

export class ApiError extends Error {
  constructor(message, { status = 0, transient = false, retryAfterMs = 0 } = {}) {
    super(message);
    Object.assign(this, { status, transient, retryAfterMs });
  }
}

export function parseTaskId(value) {
  if (!/^\d+$/.test(String(value))) throw new Error('Use a numeric taskId, not img_...');
  const id = Number(value);
  if (!Number.isSafeInteger(id) || id <= 0) throw new Error('Invalid taskId');
  return id;
}

export function retryAfter(value, now) {
  if (!value) return 0;
  if (/^\d+(\.\d+)?$/.test(value)) return Number(value) * 1000;
  const date = Date.parse(value);
  return Number.isFinite(date) ? Math.max(0, date - now) : 0;
}

export function createClient({
  apiKey,
  fetchImpl = fetch,
  now = Date.now,
  wait = sleep,
  random = Math.random,
  requestTimeoutMs = 30_000,
  pollTimeoutMs = 300_000,
  maxConsecutiveErrors = 5,
} = {}) {
  if (typeof apiKey !== 'string' || !apiKey.trim()) throw new Error('Set PIXMIND_API_KEY');

  async function request(path, method, payload, timeoutMs = requestTimeoutMs) {
    let response;
    let body;
    try {
      response = await fetchImpl(`${BASE_URL}${path}`, {
        method,
        redirect: 'error',
        headers: {
          Authorization: `Bearer ${apiKey}`,
          ...(payload ? { 'Content-Type': 'application/json' } : {}),
        },
        ...(payload ? { body: JSON.stringify(payload) } : {}),
        signal: AbortSignal.timeout(Math.max(1, Math.ceil(timeoutMs))),
      });
      // Read the body inside the timeout/network error boundary as well.
      body = await response.text();
    } catch {
      throw new ApiError('Network error or request timeout', { transient: true });
    }
    let envelope;
    try { envelope = JSON.parse(body); } catch { /* handle below */ }
    const transient = response.status === 429 || response.status >= 500;
    if (!response.ok) {
      // Do not echo arbitrary server bodies, prompts, credentials, or output URLs.
      throw new ApiError(`HTTP ${response.status}; inspect the account and request`, {
        status: response.status,
        transient,
        retryAfterMs: retryAfter(response.headers.get('retry-after'), now()),
      });
    }
    if (!envelope || typeof envelope !== 'object') {
      throw new ApiError('Expected a JSON API response');
    }
    if (envelope.code !== 1000 || !envelope.data) {
      throw new ApiError('API returned an unsuccessful or incomplete envelope');
    }
    return envelope.data;
  }

  async function submit({ model = 'nano-banana-pro', prompt } = {}) {
    if (typeof model !== 'string' || !model.trim()) throw new Error('A model is required');
    if (typeof prompt !== 'string' || !prompt.trim()) throw new Error('A prompt is required');
    try {
      const data = await request('/generations', 'POST', {
        model, type: 'image', prompt, aspectRatio: '1:1', resolution: '1K',
      });
      // The public media contract returns a number, not the prefixed display ID.
      if (typeof data.taskId !== 'number') throw new Error('Missing numeric taskId');
      return parseTaskId(data.taskId);
    } catch (error) {
      // A timeout or malformed response does not prove that creation failed.
      throw new Error(`Submission not confirmed: ${error.message}. No automatic retry was made. Check task records before submitting again.`);
    }
  }

  async function poll(taskId) {
    const id = parseTaskId(taskId);
    const deadline = now() + pollTimeoutMs;
    let attempts = 0;
    let errors = 0;
    const timedOut = () => new Error(`Stopped waiting for task ${id}; it may still be running. Resume this ID later.`);
    while (now() < deadline) {
      let retryFloor = 0;
      let task;
      try {
        task = await request(`/tasks/${id}`, 'GET', undefined,
          Math.min(requestTimeoutMs, deadline - now()));
        errors = 0;
      } catch (error) {
        if (now() >= deadline) throw timedOut();
        if (!(error instanceof ApiError) || !error.transient) throw error;
        errors += 1;
        if (errors >= maxConsecutiveErrors) {
          throw new Error(`Stopped after ${errors} consecutive query errors for task ${id}; resume this ID later.`);
        }
        retryFloor = error.retryAfterMs;
      }
      if (now() >= deadline) throw timedOut();
      if (task) {
        if (task.taskId !== id) throw new Error('Task response ID does not match the requested task');
        if (task.status === 'failed') throw new Error(`Task ${id} failed; inspect its record before creating another task.`);
        if (task.status === 'ready') {
          if (!Array.isArray(task.images) || task.images.length === 0 ||
              !task.images.every(url => {
                try { return ['https:', 'http:'].includes(new URL(url).protocol); }
                catch { return false; }
              })) throw new Error(`Task ${id} is ready but has no valid image URLs`);
          return task.images;
        }
        if (!['pending', 'processing'].includes(task.status)) {
          throw new Error(`Task ${id} returned an unrecognized status; inspect its record.`);
        }
      }
      // Client policy, not a PixMind latency guarantee or server-side retry feature.
      const ceiling = Math.min(10_000, 1_000 * 2 ** Math.min(attempts++, 4));
      const delay = Math.max(retryFloor, ceiling * (0.5 + 0.5 * random()));
      const remaining = deadline - now();
      if (delay >= remaining) {
        // Never poll earlier than Retry-After just to fit the local deadline.
        await wait(Math.max(0, remaining));
        throw timedOut();
      }
      await wait(delay);
    }
    throw timedOut();
  }

  return { submit, poll };
}

export async function main(args = process.argv.slice(2), env = process.env, deps = {}) {
  const log = deps.log ?? console.log;
  const [mode, rawId] = args;
  if (!mode) {
    log('Usage: node examples/pixmind-image.mjs submit | resume TASK_ID');
    return;
  }
  if (!((mode === 'submit' && args.length === 1) || (mode === 'resume' && args.length === 2))) {
    throw new Error('Use submit, or resume followed by a numeric taskId');
  }
  const resumeId = mode === 'resume' ? parseTaskId(rawId) : undefined;
  const client = createClient({ ...deps, apiKey: env.PIXMIND_API_KEY });
  const id = resumeId ?? await client.submit({
    model: env.PIXMIND_MODEL || 'nano-banana-pro',
    prompt: env.PIXMIND_PROMPT || 'A studio photograph of an unbranded ceramic coffee cup on a plain background',
  });
  // Save this line in your application record before relying on the polling process.
  log(`TASK_ID=${id}`);
  log(`Resume without a new generation: node examples/pixmind-image.mjs resume ${id}`);
  const images = await client.poll(id);
  log(JSON.stringify({ taskId: id, images }, null, 2));
}

if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
  main().catch(error => { console.error(error.message); process.exitCode = 1; });
}

Primero revisa la interfaz de comandos sin enviar ninguna solicitud:

node examples/pixmind-image.mjs

Después de comprobar la clave, los parámetros del modelo y el cargo previsto, crea una tarea:

node examples/pixmind-image.mjs submit

Cuando la creación se completa correctamente, el cliente muestra TASK_ID de inmediato, antes de esperar la imagen. Copia el valor real en un lugar privado. Este ejemplo no lo guarda en un archivo ni en una base de datos, así que, si no has guardado la salida, cerrar la terminal puede hacerte perder la referencia necesaria para retomar la consulta.

Para seguir consultando una tarea, sustituye 12345 por ese valor guardado:

node examples/pixmind-image.mjs resume 12345

Este comando solo realiza solicitudes GET de consulta de tareas. No lee un prompt nuevo ni crea otra imagen. Si la tarea termina correctamente, debería mostrar las URL de salida de tu propia tarea; aquí no se proporciona ningún resultado de producción inventado como referencia comparativa.

El ejemplo utiliza un límite de 30 segundos por solicitud HTTP y un plazo máximo de cinco minutos para la consulta periódica. Los reintentos GET aplican una espera exponencial con variación aleatoria, un límite local de espera de 10 segundos y, cuando corresponde, un encabezado de respuesta Retry-After válido. Una espera mayor solicitada por el servidor tiene prioridad; si no cabe dentro del plazo local, el cliente se detiene sin consultar antes de tiempo. El quinto error GET transitorio consecutivo pone fin al intento, lo que permite cuatro reintentos en esa secuencia de errores. Estos valores son ajustes del cliente, no un acuerdo de nivel de servicio ni una promesa de que todas las imágenes estarán listas en cinco minutos.

Elige una política de espera total adecuada para tu aplicación. Un trabajo prolongado puede durar más que una sesión de terminal o una solicitud web. En un servicio desplegado, guarda el ID de tarea junto con tu propio registro del trabajo y ofrece al navegador un endpoint independiente de consulta de estado, en lugar de obligar al usuario a mantener una conexión abierta.

Gestiona los errores sin duplicar trabajos de pago

Trata la incertidumbre sobre la creación de forma distinta a un fallo en la consulta de estado. Un GET de consulta de tarea puede repetirse sin crear otra generación. Un POST de creación cuya respuesta se perdió puede haber iniciado ya el trabajo, por lo que el ejemplo nunca lo reenvía automáticamente.

No supongas que todos los errores comparten el mismo formato de respuesta. En la comprobación en producción del 4 de septiembre, GET /models sin autenticación devolvió HTTP 401 con solo code y message; las respuestas correctas de contenido multimedia con autenticación también incluían data y timestamp. Por tanto, este tutorial no garantiza la presencia de requestId, un indicador retryable ni un campo de precio en todas las respuestas. Los demás casos de error de la tabla describen cómo los gestiona el cliente, no afirman que cada uno se haya reproducido en producción. Conserva el estado HTTP y, cuando exista, un mensaje de la aplicación sin información sensible; trata los cuerpos de respuesta malformados como errores en lugar de dejar que el proceso falle dentro de JSON.parse.

Que la consulta periódica agote su tiempo de espera significa que el cliente dejó de esperar, no que la tarea remota se haya cancelado. Conserva el ID y reanuda la consulta más tarde. Un estado desconocido tampoco demuestra que la tarea haya terminado correctamente: este cliente se detiene y lo comunica para su revisión. Nunca pases por defecto a «completado» porque un valor no aparezca en una sentencia switch.

Para resolver problemas, conserva el ID de tarea, el ID de modelo, la operación, el estado HTTP y la hora aproximada. Evita registrar encabezados de autorización o cuerpos completos de solicitudes que contengan prompts privados. Comprueba si los cuerpos de respuesta de diagnóstico o las URL de salida contienen información sensible antes de compartirlos.

Adapta el patrón para video y chat

El video puede seguir la misma idea de enviar una solicitud y consultar su estado, pero necesita su propia validación de solicitudes y lectura de resultados. Comprueba los archivos de entrada, la duración, la resolución y las opciones de audio que requiere el modelo de video seleccionado, en lugar de dar por hecho que puedes reutilizar los campos del cuerpo de la solicitud de imagen. Un video completado utiliza data.videoUrl, no data.images.

La guía de Video Agent explica un proceso creativo interactivo. Puede ayudarte a definir el plano que buscas antes de automatizar la generación, pero que exista una función en Agent no demuestra que haya un parámetro de API con el mismo nombre.

El chat sigue una vía de integración distinta. La ruta documentada /chat/completions es compatible con OpenAI y devuelve una respuesta de chat, o un flujo de datos si se solicita la transmisión en continuo. No pases esa respuesta al analizador de data.taskId del cliente de imágenes. Compartir una URL base no implica que todos los endpoints tengan la misma estructura de respuesta.

Mantén el cliente centrado en las imágenes hasta verificar ese flujo. Añade un adaptador de video o un cliente de chat por separado, con pruebas específicas para su formato de respuesta. Esa separación resulta más fácil de entender que una sola función que intenta adivinar si el objeto recibido es una tarea de imagen, una tarea de video o un mensaje de chat.

Verifica tu integración y elige el siguiente paso

Las pruebas locales con respuestas simuladas comprueban el comportamiento del cliente sin gastar saldo de la API. La batería de pruebas adjunta superó 29 pruebas en el entorno de Windows y Node.js indicado, incluidas la ruta de envío con un solo POST, la reanudación solo mediante GET, las respuestas malformadas, el estado final de fallo, los plazos máximos y los límites de reintento. Guarda el archivo de pruebas adjunto junto al código del cliente y ejecuta la batería desde la carpeta del tutorial:

node --test examples/pixmind-image.test.mjs

Las pruebas con respuestas simuladas no demuestran la disponibilidad ni la facturación en producción. Una comprobación controlada independiente, realizada el 4 de septiembre de 2026, utilizó el mismo cliente con el siguiente alcance registrado:

La comprobación utilizó una clave de API ya existente del proyecto, un prompt sin información sensible, ninguna carga de archivos de referencia y ningún reintento automático de creación. El asiento contable se vinculó al ID de tarea, en lugar de deducir el cargo a partir del saldo mostrado en Studio. Solo se probaron en producción esta configuración y el flujo de imagen completado correctamente; no se probaron video, chat, facturación de tareas fallidas, reembolsos ni fiabilidad en ejecuciones repetidas. Vuelve a comprobar el precio antes de enviar tu propia solicitud, en lugar de considerar este cargo histórico una cotización vigente.

Antes de conectar el ejemplo a un flujo real orientado al usuario, comprueba lo siguiente:

• La clave permanece en el servidor y no aparece en el código distribuido al cliente, las capturas de pantalla ni los registros públicos.
• El modelo seleccionado y todos sus parámetros son compatibles con la oferta actual de la API.
• Una solicitud aceptada te deja un ID numérico de tarea que puedes recuperar.
• resume no realiza ningún POST de creación, ni siquiera después de errores transitorios de consulta.
• Un fallo de tarea, un resultado vacío y un tiempo de espera local agotado producen diagnósticos distintos.
• La pérdida de una respuesta de creación no desencadena un segundo envío automático.

Para tu propia comprobación controlada en producción, registra la cuenta, el modelo, el alcance de gasto autorizado, la solicitud sin información sensible, el ID de tarea, la respuesta final y el asiento de facturación real. Inspecciona el resultado por separado de la comprobación de que su URL existe. No ejecutes «pruebas de humo» repetidas sin tener en cuenta que cada nuevo envío puede crear un trabajo de pago.

Cuando estés listo, crea una clave de API y elige un único método de envío. Desarrolla primero el flujo basado en conservar y consultar las tareas antes de añadir colas, cargas de archivos o procesamiento por lotes. Si tu siguiente paso es integrar los recursos generados en un proceso de revisión creativa, el flujo de anuncios de producto con Canvas ofrece un ejemplo independiente dirigido por personas; no promete que los proyectos de Canvas puedan ejecutarse a través de esta API.

Responsabilidad editorial: PixMind Editorial Team es la firma institucional de este tutorial. La evidencia que lo sustenta procede de la documentación oficial, la implementación del controlador de contenido multimedia del proyecto, 29 pruebas locales con respuestas simuladas y la única comprobación en producción descrita anteriormente, todo ello revisado el 4 de septiembre de 2026. Los registros de tareas y facturación, sin información sensible, se conservan para la verificación editorial. No se atribuyen credenciales a ningún ingeniero en particular ni se presentan resultados comparativos de calidad de modelos o pruebas de rendimiento.

Video con Wan 3.0: guía completa de entradas, audio, precios y API