> ## Documentation Index
> Fetch the complete documentation index at: https://docs.comfy.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Usa Wan 2.7 T2V con Comfy Router

> Fragmentos de Python, TypeScript y cURL para llamar a wan/wan2.7-t2v por HTTP con Comfy Router, además de los campos de la solicitud y la forma del resultado

Referencia de API para Wan 2.7 T2V. Wan 2.7 texto a video genera un video corto a partir de un prompt, en 720P o 1080P y de 2 a 15 segundos.

**Entrada:** Texto · **Salida:** Video + Audio

## Inicio rápido

Crea una clave en [tu espacio de trabajo de Comfy](https://platform.comfy.org/profile/api-keys?onboarding=router) y expórtala como `COMFY_API_KEY`. Los fragmentos de Python y TypeScript usan los SDK de Comfy (`pip install comfy-sdk` y `npm install @comfyorg/sdk`); el fragmento de cURL es la misma llamada sobre HTTP directo.

**ID del modelo:** `wan/wan2.7-t2v`

**Endpoint:** `POST https://api.comfy.org/v2/models/wan/wan2.7-t2v`

**Espera el resultado**

```python Python theme={null}
import asyncio
from comfy_sdk import AsyncComfy

# Lee COMFY_API_KEY del entorno.
# El SDK crea automáticamente una clave de idempotencia y la reutiliza para los reintentos automáticos.
async def main():
    async with AsyncComfy() as client:
        result = await client.models.run(
            "wan/wan2.7-t2v",
            {
                "input": {
                    "prompt": "a single red maple leaf falling onto still water, slow motion, shallow depth of field",
                },
                "parameters": {
                    "resolution": "720P",
                    "duration": 5,
                },
            },
        )

    print("video:", result["output"]["video_url"])

asyncio.run(main())
```

```typescript TypeScript theme={null}
import { comfy } from "@comfyorg/sdk";

// Lee COMFY_API_KEY del entorno.
// El SDK crea automáticamente una clave de idempotencia y la reutiliza para los reintentos automáticos.
type Result = { output: { video_url: string } };
const result = await comfy.models.run<Result>("wan/wan2.7-t2v", {
  input: {
    prompt: "a single red maple leaf falling onto still water, slow motion, shallow depth of field",
  },
  parameters: {
    resolution: "720P",
    duration: 5,
  },
});
if (result.kind !== "json") throw new Error("expected a JSON result");

console.log("video:", result.data.output.video_url);
```

```bash cURL theme={null}
curl https://api.comfy.org/v2/models/wan/wan2.7-t2v \
  -H "X-API-Key: $COMFY_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d "{\"input\": {\"prompt\":\"a single red maple leaf falling onto still water, slow motion, shallow depth of field\"}, \"parameters\": {\"resolution\":\"720P\",\"duration\":5}}"
```

**Encola y recoge más tarde**

El mismo cuerpo, enviado a `POST https://api.comfy.org/v2/models/wan/wan2.7-t2v/requests`. Router responde `201` con un `request_id` en cuanto se admite la ejecución, y el resultado se recoge cuando está listo, desde este proceso o desde otro. [Entrega en cola](https://docs.comfy.org/es/development/comfy-router/queue.md) explica el estado, la cancelación y la recogida.

```python Python theme={null}
import asyncio
from comfy_sdk import AsyncComfy

# Lee COMFY_API_KEY del entorno.
# Cada llamada a submit() genera su propia Idempotency-Key y la reutiliza para los reintentos automáticos.
async def main():
    async with AsyncComfy() as client:
        handle = await client.models.submit(
            "wan/wan2.7-t2v",
            {
                "input": {
                    "prompt": "a single red maple leaf falling onto still water, slow motion, shallow depth of field",
                },
                "parameters": {
                    "resolution": "720P",
                    "duration": 5,
                },
            },
        )
        print("request_id:", handle.request_id)  # con el ID del modelo, todo lo que necesita otro proceso

        # Consulta hasta que la solicitud se complete, esperando el Retry-After que indica el servidor.
        async for update in handle.iter_events():
            print(update.status, update.queue_position)

        # La carga propia del proveedor, el mismo valor que devuelve models.run().
        # Una solicitud fallida o cancelada lanza aquí el error tipado de Router.
        result = await handle.get()

    print("video:", result["output"]["video_url"])

asyncio.run(main())
```

```typescript TypeScript theme={null}
import { comfy } from "@comfyorg/sdk";

// Lee COMFY_API_KEY del entorno.
// Cada llamada a submit() genera su propia Idempotency-Key y la reutiliza para los reintentos automáticos.
type Result = { output: { video_url: string } };
const handle = await comfy.models.submit<Result>("wan/wan2.7-t2v", {
  input: {
    prompt: "a single red maple leaf falling onto still water, slow motion, shallow depth of field",
  },
  parameters: {
    resolution: "720P",
    duration: 5,
  },
});
console.log("requestId:", handle.requestId); // con el ID del modelo, todo lo que necesita otro proceso

// Consulta hasta que la solicitud se complete, esperando el Retry-After que indica el servidor.
for await (const update of handle.events()) {
  console.log(update.status, update.queuePosition);
}

// El mismo resultado que devuelve models.run(). Una solicitud fallida o cancelada se rechaza aquí.
const result = await handle.get();
if (result.kind !== "json") throw new Error("expected a JSON result");

console.log("video:", result.data.output.video_url);
```

```bash cURL theme={null}
# 1. Envía. Router responde 201 con request_id, status_url, response_url y cancel_url.
curl https://api.comfy.org/v2/models/wan/wan2.7-t2v/requests \
  -H "X-API-Key: $COMFY_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d "{\"input\": {\"prompt\":\"a single red maple leaf falling onto still water, slow motion, shallow depth of field\"}, \"parameters\": {\"resolution\":\"720P\",\"duration\":5}}"

# 2. Consulta hasta que el estado sea COMPLETED, esperando los segundos de Retry-After que indica cada respuesta.
REQUEST_ID="<request_id from the 201 body>"
curl -i https://api.comfy.org/v2/models/wan/wan2.7-t2v/requests/$REQUEST_ID/status \
  -H "X-API-Key: $COMFY_API_KEY"

# 3. Recoge. 200 con la salida nativa del modelo, 202 con el cuerpo de estado mientras sigue en ejecución.
curl https://api.comfy.org/v2/models/wan/wan2.7-t2v/requests/$REQUEST_ID \
  -H "X-API-Key: $COMFY_API_KEY"
```

## Esquema

### Entrada

**input** `object` *required*

Ingresa información básica, como palabras del prompt, etc.

**input.audio\_url** `string`

URL de descarga del archivo de audio. Formatos admitidos: mp3 y wav. No se puede usar junto con reference\_video\_urls.

**input.img\_url** `string`

URL de la imagen del primer fotograma o datos codificados en Base64. Requerido para los
modelos wan2.5-i2v-preview y wan2.6-i2v. Las variantes i2v de happyhorse-1.x NO toman aquí
su primer fotograma: lo toman como un elemento media de tipo first\_frame (consulta media
más abajo), y un cuerpo img\_url que funciona en wan2.6-i2v es rechazado por el proveedor en
happyhorse-1.0-i2v y happyhorse-1.1-i2v. Además, las variantes wan2.7/wan3.0 también toman
sus recursos de referencia en media. Formatos de imagen: JPEG, JPG, PNG, BMP, WEBP.
Resolución: 360-2000 píxeles. Tamaño del archivo: máx 10MB.

**input.media** `object[]`

Lista de recursos multimedia. Especifica materiales de referencia (imagen, audio,
video) para la generación de video. Cada elemento contiene un campo type y un campo url.
Este campo lo comparten todos los modelos servidos desde este componente, y qué valores
de type acepta un modelo dado (y si lleva su entrada de imagen o video aquí en lugar de
en img\_url o reference\_video\_urls) varía según el modelo. Valores de type admitidos, por
modelo:

* wan2.7-i2v: first\_frame, last\_frame, driving\_audio, first\_clip. first\_frame y
  last\_frame: JPEG/JPG/PNG/BMP/WEBP, 240-8000 píxeles por lado, relación de aspecto
  entre 1:8 y 8:1, como máximo 20MB, una URL pública o una URL
  data:\{MIME\_type};base64,... driving\_audio (WAV/MP3, de 2 a 30 segundos, como máximo
  15MB) y first\_clip (MP4/MOV, de 2 a 10 segundos, 240-4096 píxeles por lado, como
  máximo 100MB): una URL pública HTTP/HTTPS; no se acepta una URL data: en línea.
* wan2.7-r2v: first\_frame (opcional, máx. 1), reference\_image, reference\_video. Se
  requiere al menos un reference\_image o un reference\_video, y la suma de imágenes de
  referencia y videos de referencia es como máximo 5. first\_frame y reference\_image:
  JPEG/JPG/PNG/BMP/WEBP (sin canal alfa), 240-8000 píxeles por lado, relación de aspecto
  entre 1:8 y 8:1, como máximo 20MB, una URL pública o una URL
  data:\{MIME\_type};base64,... reference\_video: una URL pública HTTP/HTTPS; no se acepta
  una URL data: en línea.
* wan2.7-videoedit: video (exactamente 1, el clip que se edita: MP4/MOV, de 2 a 10
  segundos, 240-4096 píxeles por lado, como máximo 100MB, una URL pública HTTP/HTTPS; no
  se acepta una URL data: en línea) más un reference\_image opcional, de 0 a 4
  (JPEG/JPG/PNG/BMP/WEBP, 240-8000 píxeles por lado, relación de aspecto entre 1:8 y
  8:1, como máximo 20MB, una URL pública o una URL data:\{MIME\_type};base64,...).
* wan3.0-video, wan3.0-video-prime: first\_frame (máx. 1), last\_frame (máx. 1),
  reference\_image (máx. 10), reference\_video (máx. 5 clips, duración total \<= 15s),
  reference\_audio (máx. 5 clips, duración total \<= 15s), file (máx. 1, no se puede usar
  con link), link (máx. 1, no se puede usar con file). Los tipos reference\_\*/file/link y
  los tipos first\_frame/last\_frame son mutuamente excluyentes dentro de una misma
  solicitud. El orden del array define el orden de referencia de los recursos en el
  prompt (Imagen 1, Video 1, Audio 1, ...). first\_frame, last\_frame y reference\_image:
  JPEG/JPG/PNG/BMP/WEBP, 240-8000 píxeles por lado, relación de aspecto como máximo 8:1,
  como máximo 20MB, una URL pública o una URL data:\{MIME\_type};base64,...
  reference\_video, reference\_audio, file y link: una URL pública HTTP/HTTPS; no se
  acepta una URL data: en línea.
* happyhorse-1.0-i2v, happyhorse-1.1-i2v: solo first\_frame, exactamente 1. Estas
  variantes toman su primer fotograma AQUÍ y no en img\_url. Al menos 300x300 píxeles,
  relación de aspecto entre 1:2.5 y 2.5:1, JPEG/JPG/PNG/WEBP, como máximo 20MB, una URL
  pública o una URL data:\{MIME\_type};base64,...
* happyhorse-1.0-r2v, happyhorse-1.1-r2v: solo reference\_image, de 1 a 9. Esta es la
  única entrada de referencia del modelo. El lado más corto debe medir al menos 400
  píxeles, JPEG/JPG/PNG/WEBP, como máximo 20MB, una URL pública o una URL
  data:\{MIME\_type};base64,... reference\_video no es un tipo de entrada para esta
  operación.
* happyhorse-1.0-video-edit: video (exactamente 1, el clip que se edita: MP4/MOV, de 3 a
  60 segundos, lado más largo como máximo 4096 píxeles, lado más corto al menos 360
  píxeles, relación de aspecto entre 1:2.5 y 2.5:1, como máximo 100MB, una URL pública
  HTTP/HTTPS; no se acepta una URL data: en línea) más un reference\_image opcional, de 0
  a 5 (JPEG/JPG/PNG/BMP/WEBP, al menos 300x300 píxeles, relación de aspecto entre 1:2.5
  y 2.5:1, como máximo 20MB, una URL pública o una URL data:\{MIME\_type};base64,...).
* happyhorse-1.0-t2v, happyhorse-1.1-t2v, wan2.7-t2v, wan2.6-t2v, wan2.5-t2v-preview:
  operaciones de texto a video. Sus referencias del socio no documentan ninguna entrada de
  medios, así que deja este campo sin definir.
* wan2.5-i2v-preview, wan2.6-i2v, wan2.6-r2v: este componente no enumera ningún
  vocabulario de medios para estas variantes. wan2.5-i2v-preview y wan2.6-i2v toman su
  primer fotograma en img\_url; wan2.6-r2v toma sus clips de referencia en
  reference\_video\_urls. Los recuentos por modelo anteriores son restricciones del socio,
  no de este esquema: no se declara minItems/maxItems en media, porque los tipos
  admisibles y sus límites difieren según el modelo. Que el esquema acepte un valor no
  implica que el proveedor lo acepte; y, en la otra dirección, las cifras de "como
  máximo 20MB" por recurso anteriores (el techo de las entradas de imagen, las únicas
  entradas que pueden enviarse en línea) son el techo del socio sobre el recurso que
  acaba recibiendo, y se aplican tal como están escritas cuando el recurso es una URL
  pública, porque esos bytes nunca pasan por Comfy. Una URL data:\{MIME\_type};base64,...
  en línea sí pasa por Comfy y también se topa con un techo de transporte: el cuerpo de
  un POST de Comfy Router está limitado a 100 MiB en total y se responde 413 por encima
  de eso, y base64 infla una carga útil en aproximadamente 4/3, así que un solo recurso
  en línea de más de unos 75 MB se rechaza antes de llegar a cualquiera de las reglas
  del socio que aparecen aquí. Con ese tamaño, un solo recurso en el propio techo de
  20MB del socio cabe en línea sin problema, así que para un solo recurso lo que obliga
  es la regla del socio; el techo de transporte obliga cuando son varios, ya que el
  límite de 100 MiB del Router acota TODA la solicitud y no cada elemento. Envía como
  URL pública cualquier cosa que se acerque a estos techos.

**input.media\[].type** `string` *required*

Tipo de recurso multimedia

Valores posibles: `first_frame`, `last_frame`, `driving_audio`, `first_clip`, `reference_image`, `reference_video`, `reference_audio`, `video`, `file`, `link`

**input.media\[].url** `string` *required*

URL del archivo multimedia: una URL HTTP/HTTPS pública o una URL inline `data:{MIME_type};base64,...` únicamente para las entradas IMAGE que la descripción de `media` de arriba enumera para cada modelo: first\_frame y last\_frame en wan2.7-i2v; first\_frame y reference\_image en wan2.7-r2v; reference\_image en wan2.7-videoedit; first\_frame, last\_frame y reference\_image en wan3.0-video y wan3.0-video-prime; first\_frame en happyhorse-1.0-i2v y happyhorse-1.1-i2v; reference\_image en happyhorse-1.0-r2v y happyhorse-1.1-r2v; y reference\_image en happyhorse-1.0-video-edit. Ninguna entrada de video, audio, archivo o enlace de ninguno de estos modelos acepta una URL data: inline. Una URL temporal `oss://dashscope-instant` del propio servicio de carga del socio, o (en wan2.7-videoedit) un `asset_id` de Asset Center, solo se resuelve contra la cuenta de Alibaba Cloud que la subió; Comfy hace la llamada al modelo con su propia clave y no expone ninguna ruta de carga, así que la URL `oss://` o el `asset_id` propios de quien llama no son una entrada admitida. Este campo no valida el esquema de la URL, así que ese valor se reenvía al socio tal cual en lugar de rechazarse aquí. Consulta la descripción de `media` para ver los límites de tamaño y píxeles por modelo y el tope de 100 MiB del cuerpo de la solicitud del Router que acota la carga inline en conjunto.

**input.negative\_prompt** `string`

Las palabras del prompt inverso se usan para describir el contenido que no quieres ver en la trama del video

**input.prompt** `string`

Palabras del prompt de texto. Admite chino e inglés, con una longitud que no supere los 800 caracteres
(hasta 20,000 caracteres para wan3.0-video; el contenido que excede el límite se trunca).
Para wan2.6-r2v con varios videos de referencia, usa 'character1', 'character2', etc. para referirte a los sujetos
en el orden de los videos de referencia. Ejemplo: "Character1 sings on the roadside, Character2 dances beside it"
Para el modo reference de wan3.0-video, usa 'Image 1', 'Video 1', 'Audio 1', etc. para referirte a los recursos multimedia
en el orden correspondiente dentro del arreglo media.

**input.reference\_video\_urls** `string[]`

URLs de video de referencia solo para el modelo wan2.6-r2v. Arreglo de 1 a 3 URLs de video.
Restricciones de entrada:

* Formato: mp4, mov
* Cantidad: 1 a 3 videos
* Duración de cada video: 2 a 30 segundos
* Tamaño de cada archivo: máx 30MB
* No se puede usar junto con audio\_url
  Duración de referencia: un video máx 5s, dos videos máx 2.5s cada uno, tres videos proporcionalmente menos.
  Facturación: según la duración de referencia real utilizada.

**input.template** `string`

Nombre de la plantilla de efecto de video. Opcional. Actualmente disponibles: squish, flying, carousel. Cuando se usa, el parámetro prompt se ignora.

**model** `string`

El ID del modelo que se va a llamar. NO está restringido en este componente: Comfy Router lo rellena desde el segmento de ruta `{model}` de `POST /v2/models/wan/{model}`, así que quien llama al Router lo omite. Una llamada directa v1 a `POST /proxy/wan/api/v1/services/aigc/video-generation/video-synthesis` DEBE proporcionarlo, y la enumeración de grafías aceptadas está en el componente propio de esa operación, `WanVideoGenerationRequest`.

**parameters** `object`

Parámetros de procesamiento de video

**parameters.audio** `boolean` (default: true)

Si se añade audio al video. Solo es compatible con wan3.0-video y wan3.0-video-prime; el proveedor no documenta ninguna opción de este tipo para el resto de los modelos wan.

**parameters.audio\_setting** `string` (default: "auto")

Ajuste de audio del video para el modelo wan2.7-videoedit.

* auto (predeterminado): el modelo lo decide de forma inteligente según el contenido del prompt
* origin: conserva de forma forzada el audio original del video de entrada

  Valores posibles: `auto`, `origin`

**parameters.duration** `integer` (default: 5)

La duración del video generado, en segundos:

* modelos wan2.5: 5 o 10 segundos
* wan2.6-t2v, wan2.6-i2v: 5, 10 o 15 segundos
* wan2.6-r2v: solo 5 o 10 segundos (sin soporte para 15s)
* wan2.7-i2v, wan2.7-t2v: entero en \[2, 15]
* wan2.7-r2v, wan2.7-videoedit: entero en \[2, 10]
* wan3.0-video: entero en \[2, 30] sin entrada de video; con entrada de video, la duración total
  del video de entrada más la duración del video de salida no debe superar los 30 segundos; -1 activa
  el modo de duración inteligente, en el que el modelo elige una duración adecuada
  Este proxy devuelve 400 si la duración queda fuera de \[-1, 30].

  Rango: `-1` a `30`

**parameters.prompt\_extend** `boolean` (default: true)

Si se habilita la reescritura inteligente del prompt. El valor predeterminado es verdadero

**parameters.ratio** `string`

Relación de aspecto del video generado. Solo para modelos wan2.7 y wan3.0.
En los modelos wan2.7, si no se proporciona, se toma un valor predeterminado según el nivel de resolución.
En wan3.0-video, adaptive (el valor predeterminado) recomienda automáticamente una relación de aspecto
adecuada según las proporciones de los recursos de entrada y la intención.

Valores posibles: `adaptive`, `16:9`, `9:16`, `1:1`, `4:3`, `3:4`

**parameters.resolution** `string`

Nivel de resolución. Los valores admitidos varían según el modelo:

* wan2.5-i2v-preview: 480P, 720P, 1080P
* modelos wan2.6 (t2v, i2v, r2v): solo 720P, 1080P (sin soporte para 480P)
* modelos wan2.7 (i2v, t2v, r2v, videoedit): 720P, 1080P (predeterminado 1080P)
* wan3.0-video, wan3.0-video-prime: 480P, 720P, 1080P (valor predeterminado en upstream: 1080P)
* happyhorse-1.0-\* (t2v, i2v, r2v, video-edit): 720P, 1080P
* happyhorse-1.1-\* (t2v, i2v, r2v): 480P, 720P, 1080P

Este proxy rechaza las solicitudes de generación de video que no incluyan ni resolution ni size, porque el nivel de resolución determina la tarifa de facturación. Convierte resolution a mayúsculas antes de comprobarla y reenvía el valor en mayúsculas, devuelve 400 cuando el valor está fuera de esta enumeración y devuelve 400 para 480P (ya se envíe como resolution o como un size de 480P) en los modelos wan2.6, wan2.7 y happyhorse-1.0 indicados arriba como modelos sin 480P.

Valores posibles: `480P`, `720P`, `1080P`

**parameters.seed** `integer`

Semilla de número aleatorio que controla la aleatoriedad del contenido generado por el modelo

Rango: `0` a `2147483647`

**parameters.shot\_type** `string` (default: "single")

Control inteligente de múltiples lentes. Solo está activo cuando prompt\_extend está habilitado. Para los modelos wan2.6 y wan2.7-r2v.

* single: Video de una sola toma (predeterminado)
* multi: Video de varias tomas

  Valores posibles: `multi`, `single`

**parameters.size** `string`

Resolución del video en formato ancho*alto. Las resoluciones admitidas varían según el modelo:
Para wan2.5 T2V: tamaños 480P (480*832, 832*480, 624*624), 720P y 1080P
Para wan2.6 T2V/R2V (sin 480P):
720P: 1280*720, 720*1280, 960*960, 1088*832, 832*1088
1080P: 1920*1080, 1080*1920, 1440*1440, 1632*1248, 1248*1632
Cuando se envían size y resolution a la vez, size determina el nivel facturado y resolution debe seguir siendo un valor que este proxy acepte para el modelo. Un size de 480P devuelve 400 en todos los modelos que la descripción de resolution indica como modelos sin 480P.

**parameters.watermark** `boolean` (default: false)

Indica si se agrega un logotipo de marca de agua; la marca de agua se ubica en la esquina inferior derecha

Generado a partir del esquema que el Router sirve en `GET /v2/models/wan/wan2.7-t2v/openapi.json`, el mismo documento con el que valida una llamada antes de que la solicitud llegue al proveedor.

### Salida

**output** `object` *required*

**output.actual\_prompt** `string`

Prompt real después de la reescritura inteligente (para tareas de video)

**output.check\_audio** `string`

URL del audio para tareas I2V con generación de audio

**output.code** `string`

El código de error de la solicitud fallida (no se devuelve si la solicitud tiene éxito)

**output.end\_time** `string`

Hora de finalización de la tarea

**output.message** `string`

Información detallada sobre la solicitud fallida (no se devuelve si la solicitud tiene éxito)

**output.orig\_prompt** `string`

Prompt de entrada original (para tareas de video)

**output.results** `object[]`

Lista de resultados de la tarea para tareas de generación de imágenes

**output.results\[].actual\_prompt** `string`

Prompt real después de la reescritura inteligente (si está habilitada)

**output.results\[].code** `string`

Código de error de la imagen (se devuelve cuando algunas tareas fallan)

**output.results\[].message** `string`

Información de error de la imagen (se devuelve cuando algunas tareas fallan)

**output.results\[].orig\_prompt** `string`

Prompt de entrada original

**output.results\[].url** `string`

Dirección URL de la imagen generada

**output.scheduled\_time** `string`

Hora de ejecución de la tarea

**output.submit\_time** `string`

Hora de envío de la tarea

**output.task\_id** `string` *required*

ID de la tarea

**output.task\_metrics** `object`

Estadísticas de resultados de la tarea para tareas de generación de imágenes

**output.task\_metrics.FAILED** `integer`

Número de tareas fallidas

**output.task\_metrics.SUCCEEDED** `integer`

Número de tareas exitosas

**output.task\_metrics.TOTAL** `integer`

Número total de tareas

**output.task\_status** `string` *required*

Estado de la tarea

Valores posibles: `PENDING`, `RUNNING`, `SUCCEEDED`, `FAILED`, `CANCELED`, `UNKNOWN`

**output.video\_url** `string`

URL del video para tareas de generación de video completadas. El enlace es válido durante 24 horas

**request\_id** `string` *required*

Identificador único de la solicitud

**usage** `object`

Estadísticas de la información de salida. Solo se cuentan los resultados exitosos

**usage.SR** `integer`

Nivel de resolución del video (tareas I2V y wan3.0-video)

**usage.duration** `number`

Duración del video generado en segundos (tareas I2V y wan3.0-video)

**usage.fps** `integer`

Frecuencia de cuadros del video generado (tareas wan3.0-video)

**usage.image\_count** `integer`

Número de imágenes generadas (tareas T2I e I2I)

**usage.input\_video\_duration** `number`

Duración del video de entrada en segundos, 0.0 cuando no hay video de entrada (tareas wan3.0-video)

**usage.output\_video\_duration** `number`

Duración del video de salida en segundos (tareas wan3.0-video)

**usage.ratio** `string`

Relación de aspecto del video generado, p. ej. 16:9 (tareas wan3.0-video)

**usage.size** `string`

Resolución de la imagen (tareas T2I e I2I)

**usage.video\_count** `integer`

Número de videos generados (tareas T2V)

**usage.video\_duration** `number`

Duración del video generado en segundos (tareas T2V)

**usage.video\_ratio** `string`

Relación de resolución del video (tareas T2V)

**code** `string`

Código de error de una solicitud fallida, informado en la RAÍZ del sobre y no dentro de `output` (no se devuelve si la solicitud tuvo éxito).

**message** `string`

Información detallada sobre una solicitud fallida, informada en la RAÍZ del sobre y no dentro de `output` (no se devuelve si la solicitud tuvo éxito). Léela antes de recurrir a `output.message`.

## Ejemplos

### Entrada

```json theme={null}
{
  "input": {
    "prompt": "a single red maple leaf falling onto still water, slow motion, shallow depth of field"
  },
  "parameters": {
    "resolution": "720P",
    "duration": 5
  }
}
```

### Salida

```json theme={null}
{
  "output": {
    "task_id": "0385dc79-5ff8-4d82-bcb6-7c1a9f2e4d60",
    "task_status": "SUCCEEDED",
    "submit_time": "2027-01-01T00:00:00.000Z",
    "scheduled_time": "2027-01-01T00:00:01.000Z",
    "end_time": "2027-01-01T00:01:04.000Z",
    "orig_prompt": "a single red maple leaf falling onto still water, slow motion, shallow depth of field",
    "actual_prompt": "a single red maple leaf falling onto still water, slow motion, shallow depth of field, soft morning light, gentle ripples spreading outward",
    "video_url": "https://.../generated.mp4"
  },
  "request_id": "7574ee8f-38a3-4b1e-9280-11c33ab46e51",
  "usage": {
    "video_count": 1,
    "video_duration": 5,
    "video_ratio": "1280*720"
  }
}
```

La URL del video es válida durante 24 horas. Descarga el video cuanto antes si necesitas conservarlo.

## Antes de lanzar

Los SDK crean una `Idempotency-Key` y la reutilizan para los reintentos automáticos. Para los reintentos manuales, reutiliza la clave original. Router puede mantener la conexión abierta hasta 10 minutos.

Cuando una solicitud falla, Router envía un encabezado de respuesta `X-Comfy-Error-Type` que explica el motivo. Un `422` significa que Router rechazó la entrada antes de llamar al proveedor, y un `413` significa que el cuerpo de la solicitud era más grande de lo que Router acepta. Descarga los recursos generados de inmediato, porque [las URL de resultados pueden caducar](https://docs.comfy.org/es/development/comfy-router/reference.md#recursos-del-resultado).

Cualquier límite de tamaño mencionado en la descripción de un campo más arriba es el límite propio del proveedor para ese campo, citado de la especificación del proveedor. Router aplica un tope aparte al cuerpo completo de la solicitud, con el que cuentan los medios codificados en base64: consulta [tamaño del cuerpo de la solicitud](https://docs.comfy.org/es/development/comfy-router/limitations.md#los-cuerpos-de-las-solicitudes-tienen-un-límite).

Esta página documenta un modelo socio al que se llama a través de Comfy Router. El mismo paquete `comfy-sdk` / `@comfyorg/sdk` también incluye un segundo cliente, para ejecutar todo un gráfico de flujo de trabajo de ComfyUI en Comfy Cloud: `Comfy(api_key=...)` / `new Comfy({ apiKey })`, con `client.workflows`, `client.assets` y `client.jobs`. Consulta [SDK de Comfy](https://docs.comfy.org/es/development/api-development/sdks.md).

> **[Encabezados](https://docs.comfy.org/es/development/comfy-router/headers.md)**
>
> Autenticación, idempotencia, IDs de solicitud, agrupaciones de errores, ritmo de reintentos y límites de gasto.

> **[Uso de la API de Router](https://docs.comfy.org/es/development/comfy-router/api.md)**
>
> Descubrimiento de modelos, errores de validación, reintentos y facturación.

> **[Limitaciones](https://docs.comfy.org/es/development/comfy-router/limitations.md)**
>
> Lo que Router no hace hoy y qué usar en su lugar.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.