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

# Generación de Video Wan2.6

>  - Modelo de generación de video Wanxiang de Alibaba Cloud
- Soporta Text-to-Video e Image-to-Video
- Soporta resolución 720p/1080p, duración de 5/10/15 segundos
- Soporta extensión automática del prompt y generación de audio 

<RequestExample>
  ```bash cURL theme={null}
  curl --request POST \
    --url https://api.apimart.ai/v1/videos/generations \
    --header 'Authorization: Bearer <token>' \
    --header 'Content-Type: application/json' \
    --data '{
      "model": "wan2.6",
      "prompt": "A cute cat running on the grass",
      "aspect_ratio": "16:9",
      "resolution": "720p",
      "duration": 5
    }'
  ```

  ```python Python theme={null}
  import requests

  url = "https://api.apimart.ai/v1/videos/generations"

  payload = {
      "model": "wan2.6",
      "prompt": "A cute cat running on the grass",
      "aspect_ratio": "16:9",
      "resolution": "720p",
      "duration": 5
  }

  headers = {
      "Authorization": "Bearer <token>",
      "Content-Type": "application/json"
  }

  response = requests.post(url, json=payload, headers=headers)

  print(response.json())
  ```

  ```javascript JavaScript theme={null}
  const url = "https://api.apimart.ai/v1/videos/generations";

  const payload = {
    model: "wan2.6",
    prompt: "A cute cat running on the grass",
    aspect_ratio: "16:9",
    resolution: "720p",
    duration: 5
  };

  const headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  };

  fetch(url, {
    method: "POST",
    headers: headers,
    body: JSON.stringify(payload)
  })
    .then(response => response.json())
    .then(data => console.log(data))
    .catch(error => console.error('Error:', error));
  ```

  ```go Go theme={null}
  package main

  import (
      "bytes"
      "encoding/json"
      "fmt"
      "io/ioutil"
      "net/http"
  )

  func main() {
      url := "https://api.apimart.ai/v1/videos/generations"

      payload := map[string]interface{}{
          "model":        "wan2.6",
          "prompt":       "A cute cat running on the grass",
          "aspect_ratio": "16:9",
          "resolution":   "720p",
          "duration":     5,
      }

      jsonData, _ := json.Marshal(payload)

      req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
      req.Header.Set("Authorization", "Bearer <token>")
      req.Header.Set("Content-Type", "application/json")

      client := &http.Client{}
      resp, err := client.Do(req)
      if err != nil {
          panic(err)
      }
      defer resp.Body.Close()

      body, _ := ioutil.ReadAll(resp.Body)
      fmt.Println(string(body))
  }
  ```

  ```java Java theme={null}
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;
  import java.net.URI;

  public class Main {
      public static void main(String[] args) throws Exception {
          String url = "https://api.apimart.ai/v1/videos/generations";

          String payload = """
          {
            "model": "wan2.6",
            "prompt": "A cute cat running on the grass",
            "aspect_ratio": "16:9",
            "resolution": "720p",
            "duration": 5
          }
          """;

          HttpClient client = HttpClient.newHttpClient();
          HttpRequest request = HttpRequest.newBuilder()
              .uri(URI.create(url))
              .header("Authorization", "Bearer <token>")
              .header("Content-Type", "application/json")
              .POST(HttpRequest.BodyPublishers.ofString(payload))
              .build();

          HttpResponse<String> response = client.send(request,
              HttpResponse.BodyHandlers.ofString());

          System.out.println(response.body());
      }
  }
  ```

  ```php PHP theme={null}
  <?php

  $url = "https://api.apimart.ai/v1/videos/generations";

  $payload = [
      "model" => "wan2.6",
      "prompt" => "A cute cat running on the grass",
      "aspect_ratio" => "16:9",
      "resolution" => "720p",
      "duration" => 5
  ];

  $ch = curl_init($url);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_POST, true);
  curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
      "Authorization: Bearer <token>",
      "Content-Type: application/json"
  ]);

  $response = curl_exec($ch);
  curl_close($ch);

  echo $response;
  ?>
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'json'
  require 'uri'

  url = URI("https://api.apimart.ai/v1/videos/generations")

  payload = {
    model: "wan2.6",
    prompt: "A cute cat running on the grass",
    aspect_ratio: "16:9",
    resolution: "720p",
    duration: 5
  }

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true

  request = Net::HTTP::Post.new(url)
  request["Authorization"] = "Bearer <token>"
  request["Content-Type"] = "application/json"
  request.body = payload.to_json

  response = http.request(request)
  puts response.body
  ```

  ```swift Swift theme={null}
  import Foundation

  let url = URL(string: "https://api.apimart.ai/v1/videos/generations")!

  let payload: [String: Any] = [
      "model": "wan2.6",
      "prompt": "A cute cat running on the grass",
      "aspect_ratio": "16:9",
      "resolution": "720p",
      "duration": 5
  ]

  var request = URLRequest(url: url)
  request.httpMethod = "POST"
  request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
  request.setValue("application/json", forHTTPHeaderField: "Content-Type")
  request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

  let task = URLSession.shared.dataTask(with: request) { data, response, error in
      if let error = error {
          print("Error: \(error)")
          return
      }

      if let data = data, let responseString = String(data: data, encoding: .utf8) {
          print(responseString)
      }
  }

  task.resume()
  ```

  ```csharp C# theme={null}
  using System;
  using System.Net.Http;
  using System.Text;
  using System.Threading.Tasks;

  class Program
  {
      static async Task Main(string[] args)
      {
          var url = "https://api.apimart.ai/v1/videos/generations";

          var payload = @"{
              ""model"": ""wan2.6"",
              ""prompt"": ""A cute cat running on the grass"",
              ""aspect_ratio"": ""16:9"",
              ""resolution"": ""720p"",
              ""duration"": 5
          }";

          using var client = new HttpClient();
          client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");

          var content = new StringContent(payload, Encoding.UTF8, "application/json");
          var response = await client.PostAsync(url, content);
          var result = await response.Content.ReadAsStringAsync();

          Console.WriteLine(result);
      }
  }
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "code": 200,
    "data": [
      {
        "status": "submitted",
        "task_id": "task_01J9HA7JPQ9A0Z6JZ3V8M9W6PZ"
      }
    ]
  }
  ```

  ```json 400 theme={null}
  {
    "error": {
      "code": 400,
      "message": "Invalid request parameters",
      "type": "invalid_request_error"
    }
  }
  ```

  ```json 401 theme={null}
  {
    "error": {
      "code": 401,
      "message": "Invalid authentication credentials",
      "type": "authentication_error"
    }
  }
  ```

  ```json 402 theme={null}
  {
    "error": {
      "code": 402,
      "message": "Insufficient balance. Please top up your account",
      "type": "payment_required"
    }
  }
  ```

  ```json 429 theme={null}
  {
    "error": {
      "code": 429,
      "message": "Rate limit exceeded. Please try again later",
      "type": "rate_limit_error"
    }
  }
  ```

  ```json 500 theme={null}
  {
    "error": {
      "code": 500,
      "message": "Internal server error. Please try again later",
      "type": "server_error"
    }
  }
  ```
</ResponseExample>

## Autorización

<ParamField header="Authorization" type="string" required>
  Todos los endpoints de la API requieren autenticación mediante Bearer Token

  Obtenga su API Key:

  Visite la [página de gestión de API Keys](https://apimart.ai/keys) para obtener su API Key

  Añádala al encabezado de la solicitud:

  ```
  Authorization: Bearer YOUR_API_KEY
  ```
</ParamField>

## Parámetros de la solicitud

<ParamField body="model" type="string" required>
  Nombre del modelo de generación de video, fijado como `wan2.6`
</ParamField>

<ParamField body="prompt" type="string" required>
  Descripción del contenido del video

  Requerido para el modo text-to-video. Describa escenas, acciones y estilos en detalle para obtener mejores resultados

  Ejemplo: `"A cute cat stretching in the sunlight"`
</ParamField>

<ParamField body="image_urls" type="array<url>">
  Array de URLs de imágenes de referencia (solo se admite 1 imagen)

  Requerido para el modo image-to-video. Admite URLs de imágenes accesibles públicamente

  Ejemplo: `["https://example.com/image.jpg"]`

  <Note>
    El sistema selecciona automáticamente el modo text-to-video o image-to-video según si se incluye `image_urls`
  </Note>
</ParamField>

<ParamField body="negative_prompt" type="string">
  Prompt negativo que describe contenido no deseado

  Ejemplo: `"blurry, low quality, distorted"`
</ParamField>

<ParamField body="aspect_ratio" type="string" default="16:9">
  Proporción de aspecto del video

  Opciones:

  * `16:9` - Paisaje (por defecto)
  * `9:16` - Retrato
  * `1:1` - Cuadrado
  * `4:3` - Paisaje
  * `3:4` - Retrato

  Por defecto: `16:9`

  <Warning>
    No soportado en el modo image-to-video
  </Warning>
</ParamField>

<ParamField body="resolution" type="string" default="720p">
  Resolución del video

  Opciones:

  * `720p` - Estándar (por defecto)
  * `1080p` - Alta definición

  Por defecto: `720p`

  <Warning>
    La resolución 480p no es soportada
  </Warning>

  <Note>
    Facturado por segundo. El precio varía según la resolución. Consulte el marketplace de modelos para conocer los precios específicos
  </Note>
</ParamField>

<ParamField body="duration" type="integer" default="5">
  Duración del video (segundos)

  Valores soportados: `5`, `10`, `15` segundos únicamente

  Por defecto: `5`
</ParamField>

<ParamField body="seed" type="integer">
  Semilla aleatoria para resultados reproducibles

  Ejemplo: `12345`
</ParamField>

<ParamField body="prompt_extend" type="boolean">
  Si se debe extender automáticamente el prompt

  Cuando está activado, el sistema optimizará y enriquecerá automáticamente su prompt
</ParamField>

<ParamField body="audio" type="boolean">
  Si se debe añadir audio automáticamente

  Cuando está activado, el sistema generará audio que coincida con el video
</ParamField>

<ParamField body="audio_url" type="string">
  URL de audio especificada

  Tiene prioridad sobre el parámetro `audio`

  <Warning>
    La duración del audio no puede superar la duración del video. Si el audio es más corto que la duración del video, la primera parte del video tendrá sonido mientras que el resto será silencioso.
  </Warning>
</ParamField>

<ParamField body="shot_type" type="string">
  Tipo de toma

  Opciones:

  * `single` - Toma única
  * `multi` - Múltiples tomas
</ParamField>

<ParamField body="watermark" type="boolean">
  Si se debe añadir una marca de agua
</ParamField>

<ParamField body="template" type="string">
  Nombre de la plantilla de efecto para el modo de efectos especiales image-to-video

  <Note>
    Al usar el modo de efectos:

    * Solo se requiere una imagen (pasada mediante `image_urls`)
    * No se necesita prompt (el modelo ignora el campo `prompt`)
  </Note>

  **Efectos generales:**

  * `squish` - Squish & Squeeze
  * `rotation` - Rotación
  * `poke` - Pinchar
  * `inflate` - Inflado de globo
  * `dissolve` - Disolución molecular
  * `melt` - Derretimiento por ola de calor
  * `icecream` - Planeta helado
  * `flying` - Levitación mágica

  **Efectos para una sola persona:**

  * `carousel` - Carrusel del tiempo
  * `singleheart` - Te amo
  * `dance1` - Momento swing
  * `dance2` - Movimiento de baile

  Para más efectos, consulte la [Documentación de plantillas de Alibaba Wanxiang](https://help.aliyun.com/zh/model-studio/wanx-video-effects)
</ParamField>

## Combinaciones de resolución y proporción de aspecto

| Proporción de aspecto | Descripción           | Tamaño 720p | Tamaño 1080p |
| --------------------- | --------------------- | ----------- | ------------ |
| `16:9`                | Paisaje (por defecto) | 1280×720    | 1920×1080    |
| `9:16`                | Retrato               | 720×1280    | 1080×1920    |
| `1:1`                 | Cuadrado              | 960×960     | 1440×1440    |
| `4:3`                 | Paisaje               | 1088×832    | 1632×1248    |
| `3:4`                 | Retrato               | 832×1088    | 1248×1632    |

## Respuesta

<ResponseField name="code" type="integer">
  Código de estado de la respuesta, 200 en caso de éxito
</ResponseField>

<ResponseField name="data" type="array">
  Array de datos de la respuesta

  <Expandable title="Elementos del array">
    <ResponseField name="status" type="string">
      Estado de la tarea, `submitted` al enviarse inicialmente
    </ResponseField>

    <ResponseField name="task_id" type="string">
      Identificador único de la tarea para consultar el estado y los resultados
    </ResponseField>
  </Expandable>
</ResponseField>

## Casos de uso

### Caso 1: Texto a video (Solicitud simple)

```json theme={null}
{
  "model": "wan2.6",
  "prompt": "A cute cat stretching in the sunlight"
}
```

### Caso 2: Texto a video (Parámetros completos)

```json theme={null}
{
  "model": "wan2.6",
  "prompt": "A cute cat running on the grass",
  "negative_prompt": "blurry, low quality, distorted",
  "aspect_ratio": "16:9",
  "resolution": "720p",
  "duration": 5,
  "seed": 12345,
  "prompt_extend": true,
  "audio": true,
  "shot_type": "single",
  "watermark": false
}
```

### Caso 3: Imagen a video

```json theme={null}
{
  "model": "wan2.6",
  "prompt": "A kitten running on the ground",
  "image_urls": ["https://upload.apimart.ai/f/apimart-models-images/9998233432754770-c059992d-9b01-47d5-810d-ea0502ac9279-image_task_01KD7SSXDBCEWZ869D6PF249ZW_0.png"],
  "resolution": "1080p",
  "duration": 10
}
```

### Caso 4: Imagen a video (Imagen Base64)

```json theme={null}
{
  "model": "wan2.6",
  "prompt": "Make the cat stand up and walk",
  "image_urls": ["data:image/png;base64,iVBORw0KGgo..."],
  "duration": 5
}
```

## Descripción de modos

### Texto a video (Text-to-Video)

* El parámetro `prompt` es obligatorio
* El parámetro `image_urls` no es necesario

### Imagen a video (Image-to-Video)

* El parámetro `image_urls` es obligatorio (solo se admite 1 imagen)
* El parámetro `prompt` es opcional, se usa para describir las acciones esperadas

<Note>
  El sistema selecciona automáticamente el modo según si se incluye `image_urls` en la solicitud
</Note>

<Note>
  **Consultar resultados de la tarea**

  La generación de video es una tarea asíncrona que devuelve un `task_id` al enviarse. Use el endpoint [Obtener estado de la tarea](/es/api-reference/tasks/status) para consultar el progreso y los resultados de la generación.
</Note>