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

# 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 

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

## Autorisation

<ParamField header="Authorization" type="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://apimart.ai/keys) pour obtenir votre API Key

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

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

## Paramètres de la requête

<ParamField body="model" type="string" required>
  Nom du modèle de génération vidéo, fixé à `wan2.6`
</ParamField>

<ParamField body="prompt" type="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"`
</ParamField>

<ParamField body="image_urls" type="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
  </Note>
</ParamField>

<ParamField body="negative_prompt" type="string">
  Prompt négatif décrivant le contenu indésirable

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

<ParamField body="aspect_ratio" type="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
  </Warning>
</ParamField>

<ParamField body="resolution" type="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
  </Warning>

  <Note>
    Facturation à la seconde. Le tarif varie selon la résolution. Consultez le catalogue des modèles pour les tarifs précis
  </Note>
</ParamField>

<ParamField body="duration" type="integer" default="5">
  Durée de la vidéo (secondes)

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

  Par défaut : `5`
</ParamField>

<ParamField body="seed" type="integer">
  Graine aléatoire pour des résultats reproductibles

  Exemple : `12345`
</ParamField>

<ParamField body="prompt_extend" type="boolean">
  Étendre automatiquement le prompt

  Lorsqu'activé, le système optimise et enrichit automatiquement votre prompt
</ParamField>

<ParamField body="audio" type="boolean">
  Ajouter automatiquement un audio

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

<ParamField body="audio_url" type="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.
  </Warning>
</ParamField>

<ParamField body="shot_type" type="string">
  Type de plan

  Options :

  * `single` — plan unique
  * `multi` — plans multiples
</ParamField>

<ParamField body="watermark" type="boolean">
  Ajouter un filigrane
</ParamField>

<ParamField body="template" type="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`)
  </Note>

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

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

<ResponseField name="code" type="integer">
  Code de statut de la réponse, 200 en cas de succès
</ResponseField>

<ResponseField name="data" type="array">
  Tableau de données de la réponse

  <Expandable title="Éléments du tableau">
    <ResponseField name="status" type="string">
      Statut de la tâche, `submitted` lors de la soumission initiale
    </ResponseField>

    <ResponseField name="task_id" type="string">
      Identifiant unique de la tâche pour interroger son statut et ses résultats
    </ResponseField>
  </Expandable>
</ResponseField>

## 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.apimart.ai/f/apimart-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>

<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](/fr/api-reference/tasks/status) pour interroger la progression et les résultats de la génération.
</Note>