> ## Documentation Index
> Fetch the complete documentation index at: https://gccai.heqingsong.uk/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 

```bash cURL theme={null}
curl --request POST \
  --url https://gccai.heqingsong.uk/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://gccai.heqingsong.uk/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://gccai.heqingsong.uk/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://gccai.heqingsong.uk/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://gccai.heqingsong.uk/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://gccai.heqingsong.uk/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://gccai.heqingsong.uk/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://gccai.heqingsong.uk/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://gccai.heqingsong.uk/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);
    }
}
```

```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"
  }
}
```

## Autorización

**Authorization** `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://gccai.heqingsong.uk/keys) para obtener su API Key

Añádala al encabezado de la solicitud:

```
Authorization: Bearer YOUR_API_KEY
```

## Parámetros de la solicitud

**model** `string` *required*

Nombre del modelo de generación de video, fijado como `wan2.6`

**nsfw\_check** `boolean` (default: false)

Indica si se debe moderar el contenido antes de enviar la tarea de vídeo.

* `true`: revisar los prompts y las imágenes de entrada con `omni-moderation-latest`
* `false` u omitido: no enviar una solicitud de moderación, sin coste ni latencia de moderación adicionales (predeterminado)

**prompt** `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"`

**image\_urls** `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`

**negative\_prompt** `string`

Prompt negativo que describe contenido no deseado

Ejemplo: `"blurry, low quality, distorted"`

**aspect\_ratio** `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

**resolution** `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

> [!NOTE]
>
> Facturado por segundo. El precio varía según la resolución. Consulte el marketplace de modelos para conocer los precios específicos

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

Duración del video (segundos)

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

Por defecto: `5`

**seed** `integer`

Semilla aleatoria para resultados reproducibles

Ejemplo: `12345`

**prompt\_extend** `boolean`

Si se debe extender automáticamente el prompt

Cuando está activado, el sistema optimizará y enriquecerá automáticamente su prompt

**audio** `boolean`

Si se debe añadir audio automáticamente

Cuando está activado, el sistema generará audio que coincida con el video

**audio\_url** `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.

**shot\_type** `string`

Tipo de toma

Opciones:

* `single` - Toma única
* `multi` - Múltiples tomas

**watermark** `boolean`

Si se debe añadir una marca de agua

**template** `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`)

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

## 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

**code** `integer`

Código de estado de la respuesta, 200 en caso de éxito

**data** `array`

Array de datos de la respuesta

**Elementos del array**

**status** `string`

Estado de la tarea, `submitted` al enviarse inicialmente

**task\_id** `string`

Identificador único de la tarea para consultar el estado y los resultados

## 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.gccai.ai/f/gccai-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]
>
> **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](https://gccai.heqingsong.uk/es/api-reference/tasks/status.md) para consultar el progreso y los resultados de la generación.


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