> ## 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 MiniMax-Hailuo-2.3

>  - Mode de traitement asynchrone, renvoie un ID de tâche pour les requêtes ultérieures
- Prend en charge le texte-vers-vidéo et l'image-vers-vidéo (image de première trame)
- Prend en charge des durées de 6 et 10 secondes, résolutions 768p/1080p
- Prend en charge 15 commandes de mouvement de caméra, l'optimisation automatique du prompt et le contrôle du filigrane 

<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": "MiniMax-Hailuo-2.3",
      "prompt": "A cute kitten running on the grass",
      "duration": 6,
      "resolution": "768p",
      "prompt_optimizer": true,
      "fast_pretreatment": false,
      "watermark": false
    }'
  ```

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

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

  payload = {
      "model": "MiniMax-Hailuo-2.3",
      "prompt": "A cute kitten running on the grass",
      "duration": 6,
      "resolution": "768p",
      "prompt_optimizer": True,
      "fast_pretreatment": False,
      "watermark": False
  }

  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: "MiniMax-Hailuo-2.3",
    prompt: "A cute kitten running on the grass",
    duration: 6,
    resolution: "768p",
    prompt_optimizer: true,
    fast_pretreatment: false,
    watermark: false
  };

  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":              "MiniMax-Hailuo-2.3",
          "prompt":             "A cute kitten running on the grass",
          "duration":           6,
          "resolution":         "768p",
          "prompt_optimizer":   true,
          "fast_pretreatment":  false,
          "watermark":          false,
      }

      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": "MiniMax-Hailuo-2.3",
            "prompt": "A cute kitten running on the grass",
            "duration": 6,
            "resolution": "768p",
            "prompt_optimizer": true,
            "fast_pretreatment": false,
            "watermark": false
          }
          """;

          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" => "MiniMax-Hailuo-2.3",
      "prompt" => "A cute kitten running on the grass",
      "duration" => 6,
      "resolution" => "768p",
      "prompt_optimizer" => true,
      "fast_pretreatment" => false,
      "watermark" => false
  ];

  $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: "MiniMax-Hailuo-2.3",
    prompt: "A cute kitten running on the grass",
    duration: 6,
    resolution: "768p",
    prompt_optimizer: true,
    fast_pretreatment: false,
    watermark: false
  }

  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": "MiniMax-Hailuo-2.3",
      "prompt": "A cute kitten running on the grass",
      "duration": 6,
      "resolution": "768p",
      "prompt_optimizer": true,
      "fast_pretreatment": false,
      "watermark": false
  ]

  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"": ""MiniMax-Hailuo-2.3"",
              ""prompt"": ""A cute kitten running on the grass"",
              ""duration"": 6,
              ""resolution"": ""768p"",
              ""prompt_optimizer"": true,
              ""fast_pretreatment"": false,
              ""watermark"": false
          }";

          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>
  Modèles pris en charge :

  * `MiniMax-Hailuo-2.3` — Hailuo 2.3
  * `MiniMax-Hailuo-2.3-Fast` — Hailuo 2.3 Fast (latence réduite)

  <Warning>
    **MiniMax-Hailuo-2.3-Fast** :<br />
    Avec ce modèle, `first_frame_image` est obligatoire.
  </Warning>
</ParamField>

<ParamField body="prompt" type="string" required>
  Description du contenu de la vidéo (2000 caractères maximum)

  Décrivez les scènes, actions et styles en détail pour de meilleurs résultats. Prend en charge les commandes de mouvement de caméra (voir la section « Commandes de mouvement de caméra » ci-dessous).

  Exemple : `"A cute kitten running on the grass"`
</ParamField>

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

  Options :

  * `6` — vidéo de 6 secondes
  * `10` — vidéo de 10 secondes

  Par défaut : `6`

  <Warning>
    **Limitation 1080p** : à la résolution 1080p, seule la durée de 6 secondes est prise en charge
  </Warning>
</ParamField>

<ParamField body="resolution" type="string" default="768p">
  Résolution de la vidéo

  Options :

  * `768p` — haute définition
  * `1080p` — Full HD (uniquement 6 secondes)

  Par défaut : `768p`
</ParamField>

<ParamField body="first_frame_image" type="string">
  Image de première trame de la vidéo

  Deux formats pris en charge :

  * **URL publique** : `https://example.com/start.jpg`
  * **Encodage Base64** : `data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABg...`

  Lorsqu'elle est fournie, cette image sera utilisée comme première trame de la vidéo

  <Warning>
    **MiniMax-Hailuo-2.3-Fast** :<br />
    Avec ce modèle, `first_frame_image` est obligatoire.
  </Warning>
</ParamField>

<ParamField body="prompt_optimizer" type="boolean" default="true">
  Optimiser automatiquement le prompt

  Lorsqu'activé, le système optimise automatiquement votre prompt pour de meilleurs résultats

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

<ParamField body="fast_pretreatment" type="boolean" default="false">
  Réduire le temps d'optimisation du prompt

  Lorsqu'activé, la vitesse de traitement est plus rapide mais la qualité de l'optimisation peut être légèrement affectée

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

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

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

## Combinaisons résolution / durée

| Résolution | Durée prise en charge | Remarques               |
| ---------- | --------------------- | ----------------------- |
| 768p       | 6s, 10s               | Toutes prises en charge |
| 1080p      | 6s                    | 10s non pris en charge  |

## Commandes de mouvement de caméra

Utilisez la syntaxe `[commande]` dans le `prompt` pour contrôler les mouvements de caméra. 15 commandes sont prises en charge :

| Catégorie            | Commandes                                                    |
| -------------------- | ------------------------------------------------------------ |
| Panoramique          | `[左移]` (panoramique gauche) `[右移]` (panoramique droite)      |
| Rotation horizontale | `[左摇]` (rotation gauche) `[右摇]` (rotation droite)            |
| Avant/arrière        | `[推进]` (avancer) `[拉远]` (reculer)                            |
| Mouvement vertical   | `[上升]` (monter) `[下降]` (descendre)                           |
| Rotation verticale   | `[上摇]` (incliner vers le haut) `[下摇]` (incliner vers le bas) |
| Zoom                 | `[变焦推近]` (zoom avant) `[变焦拉远]` (zoom arrière)                |
| Autres               | `[晃动]` (tremblement) `[跟随]` (suivre) `[固定]` (statique)       |

**Exemple d'utilisation** :

```json theme={null}
{
  "model": "MiniMax-Hailuo-2.3",
  "prompt": "[推进]A cat running in the garden, camera slowly pushing in for a close-up"
}
```

## 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 : Génération rapide texte-vers-vidéo

```json theme={null}
{
  "model": "MiniMax-Hailuo-2.3",
  "prompt": "A cute kitten running on the grass, sunny day"
}
```

### Cas 2 : Vidéo 1080p de haute qualité

```json theme={null}
{
  "model": "MiniMax-Hailuo-2.3",
  "prompt": "City nightscape, neon lights flickering, traffic flowing",
  "duration": 6,
  "resolution": "1080p",
  "prompt_optimizer": true,
  "watermark": false
}
```

### Cas 3 : Image-vers-vidéo avec première trame

```json theme={null}
{
  "model": "MiniMax-Hailuo-2.3",
  "prompt": "Kitten running towards camera, smiling and blinking",
  "first_frame_image": "https://example.com/cat.jpg",
  "duration": 6,
  "resolution": "1080p"
}
```

### Cas 4 : Commandes de mouvement de caméra

```json theme={null}
{
  "model": "MiniMax-Hailuo-2.3",
  "prompt": "[推进]A cat running in the garden, camera slowly pushing in for a close-up",
  "duration": 6,
  "resolution": "768p"
}
```

### Cas 5 : Mode de prétraitement rapide

```json theme={null}
{
  "model": "MiniMax-Hailuo-2.3",
  "prompt": "Waves crashing on the beach at sunset",
  "duration": 10,
  "resolution": "768p",
  "prompt_optimizer": true,
  "fast_pretreatment": true
}
```

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