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

# Génération vidéo Wan2.6

>  - Modèle de génération vidéo Alibaba Cloud Wanxiang
- Prend en charge Text-to-Video et Image-to-Video
- Prend en charge les résolutions 720p/1080p, durée de 5/10/15 secondes
- Prend en charge l'extension automatique du prompt et la génération 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"
  }
}
```

## Autorisation

**Authorization** `string` *required*

Tous les endpoints API requièrent une authentification par Bearer Token

Obtenez votre API Key :

Visitez la [page de gestion des API Keys](https://gccai.heqingsong.uk/keys) pour obtenir votre API Key

Ajoutez-la à l'en-tête de la requête :

```
Authorization: Bearer YOUR_API_KEY
```

## Paramètres de la requête

**model** `string` *required*

Nom du modèle de génération vidéo, fixé à `wan2.6`

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

Indique s'il faut modérer le contenu avant d'envoyer la tâche vidéo.

* `true` : vérifier les prompts et les images d'entrée avec `omni-moderation-latest`
* `false` ou omis : ne pas envoyer de requête de modération, sans coût ni latence de modération supplémentaires (par défaut)

**prompt** `string` *required*

Description du contenu de la vidéo

Obligatoire en mode text-to-video. Décrivez les scènes, actions et styles en détail pour de meilleurs résultats

Exemple : `"A cute cat stretching in the sunlight"`

**image\_urls** `array\<url\>`

Tableau d'URLs d'images de référence (1 seule image prise en charge)

Obligatoire en mode image-to-video. Prend en charge les URLs d'images accessibles publiquement

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

> [!NOTE]
>
> Le système sélectionne automatiquement le mode text-to-video ou image-to-video selon que `image_urls` est inclus ou non

**negative\_prompt** `string`

Prompt négatif décrivant le contenu indésirable

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

**aspect\_ratio** `string` (default: 16:9)

Rapport d'aspect de la vidéo

Options :

* `16:9` — paysage (par défaut)
* `9:16` — portrait
* `1:1` — carré
* `4:3` — paysage
* `3:4` — portrait

Par défaut : `16:9`

> [!WARNING]
>
> Non pris en charge en mode image-to-video

**resolution** `string` (default: 720p)

Résolution de la vidéo

Options :

* `720p` — standard (par défaut)
* `1080p` — haute définition

Par défaut : `720p`

> [!WARNING]
>
> La résolution 480p n'est pas prise en charge

> [!NOTE]
>
> Facturation à la seconde. Le tarif varie selon la résolution. Consultez le catalogue des modèles pour les tarifs précis

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

Durée de la vidéo (secondes)

Valeurs prises en charge : uniquement `5`, `10`, `15` secondes

Par défaut : `5`

**seed** `integer`

Graine aléatoire pour des résultats reproductibles

Exemple : `12345`

**prompt\_extend** `boolean`

Étendre automatiquement le prompt

Lorsqu'activé, le système optimise et enrichit automatiquement votre prompt

**audio** `boolean`

Ajouter automatiquement un audio

Lorsqu'activé, le système génère un audio adapté à la vidéo

**audio\_url** `string`

URL de l'audio spécifié

Prioritaire sur le paramètre `audio`

> [!WARNING]
>
> La durée de l'audio ne peut pas dépasser la durée de la vidéo. Si l'audio est plus court que la durée de la vidéo, le début de la vidéo aura du son tandis que le reste sera silencieux.

**shot\_type** `string`

Type de plan

Options :

* `single` — plan unique
* `multi` — plans multiples

**watermark** `boolean`

Ajouter un filigrane

**template** `string`

Nom du modèle d'effet pour le mode effets spéciaux image-to-video

> [!NOTE]
>
> En mode effets :
>
> * Une seule image est requise (transmise via `image_urls`)
> * Aucun prompt n'est nécessaire (le modèle ignore le champ `prompt`)

**Effets généraux :**

* `squish` — Écrasement & compression
* `rotation` — Rotation
* `poke` — Coup d'index
* `inflate` — Gonflage de ballon
* `dissolve` — Dissolution moléculaire
* `melt` — Fonte par vague de chaleur
* `icecream` — Planète glacée
* `flying` — Lévitation magique

**Effets pour une personne :**

* `carousel` — Carrousel du temps
* `singleheart` — Love You
* `dance1` — Moment de balancement
* `dance2` — Pas de danse

Pour plus d'effets, consultez la [documentation des modèles Alibaba Wanxiang](https://help.aliyun.com/zh/model-studio/wanx-video-effects)

## Combinaisons résolution / rapport d'aspect

| Rapport d'aspect | Description | Taille 720p | Taille 1080p |
| - | - | - | - |
| `16:9` | Paysage (par défaut) | 1280×720 | 1920×1080 |
| `9:16` | Portrait | 720×1280 | 1080×1920 |
| `1:1` | Carré | 960×960 | 1440×1440 |
| `4:3` | Paysage | 1088×832 | 1632×1248 |
| `3:4` | Portrait | 832×1088 | 1248×1632 |

## Réponse

**code** `integer`

Code de statut de la réponse, 200 en cas de succès

**data** `array`

Tableau de données de la réponse

**Éléments du tableau**

**status** `string`

Statut de la tâche, `submitted` lors de la soumission initiale

**task\_id** `string`

Identifiant unique de la tâche pour interroger son statut et ses résultats

## Cas d'utilisation

### Cas 1 : Texte vers vidéo (requête simple)

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

### Cas 2 : Texte vers vidéo (paramètres complets)

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

### Cas 3 : Image vers vidéo

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

### Cas 4 : Image vers vidéo (image Base64)

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

## Description des modes

### Texte vers vidéo (Text-to-Video)

* Le paramètre `prompt` est obligatoire
* Le paramètre `image_urls` n'est pas nécessaire

### Image vers vidéo (Image-to-Video)

* Le paramètre `image_urls` est obligatoire (1 seule image prise en charge)
* Le paramètre `prompt` est optionnel, sert à décrire les actions attendues

> [!NOTE]
>
> Le système sélectionne automatiquement le mode selon que `image_urls` est inclus ou non dans la requête

> [!NOTE]
>
> **Interroger les résultats de la tâche**
>
> La génération vidéo est une tâche asynchrone qui renvoie un `task_id` lors de la soumission. Utilisez l'endpoint [Obtenir le statut de la tâche](https://gccai.heqingsong.uk/fr/api-reference/tasks/status.md) pour interroger la progression et les résultats de la génération.


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