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

# Guide de démarrage rapide de l’API Veo 3 : générer des vidéos avec CometAPI

> Créez une tâche vidéo Veo avec CometAPI, interrogez l’état de la tâche et stockez l’URL ou le fichier vidéo final avec curl, Python ou Node.js.

## Ce que vous allez créer

Vous allez créer une tâche vidéo Veo avec des données de formulaire multipart, stocker l’ID de tâche renvoyé, interroger l’endpoint de récupération et enregistrer l’URL de la ressource finale ou le fichier dans votre propre système.

## Prérequis

* Une clé API CometAPI stockée dans `COMETAPI_KEY`
* Python 3.10+ avec `requests`, ou Node.js 18+
* Un exécuteur de tâches côté serveur pour l’interrogation

## Clé API, URL de base, authentification

Créez des tâches Veo avec :

```text theme={null}
POST https://api.cometapi.com/v1/videos
```

Interrogez l’état d’une tâche Veo avec :

```text theme={null}
GET https://api.cometapi.com/v1/videos/<task_id>
```

Authentifiez-vous avec un jeton Bearer :

```text theme={null}
Authorization: Bearer $COMETAPI_KEY
```

## Exemples de code

Utilisez les onglets ci-dessous pour des exemples copiables en cURL, Python et Node.js.

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.cometapi.com/v1/videos \
    -H "Authorization: Bearer $COMETAPI_KEY" \
    -F model=veo3.1-fast \
    -F "prompt=A paper kite floats above a field." \
    -F seconds=4 \
    -F size=1280x720

  curl "https://api.cometapi.com/v1/videos/<task_id>" \
    -H "Authorization: Bearer $COMETAPI_KEY"
  ```

  ```python Python theme={null}
  import os
  import time

  import requests

  api_key = os.environ["COMETAPI_KEY"]
  headers = {"Authorization": f"Bearer {api_key}"}

  create_response = requests.post(
      "https://api.cometapi.com/v1/videos",
      headers=headers,
      files={
          "model": (None, "veo3.1-fast"),
          "prompt": (None, "A paper kite floats above a field."),
          "seconds": (None, "4"),
          "size": (None, "1280x720"),
      },
      timeout=60,
  )
  create_response.raise_for_status()
  task_id = create_response.json()["id"]

  for _ in range(60):
      retrieve_response = requests.get(
          f"https://api.cometapi.com/v1/videos/{task_id}",
          headers=headers,
          timeout=30,
      )
      retrieve_response.raise_for_status()
      task = retrieve_response.json()
      if task["status"] in {"completed", "failed", "error"}:
          print(task)
          break
      time.sleep(5)
  else:
      raise TimeoutError("Veo task did not finish in time")
  ```

  ```javascript Node.js theme={null}
  const form = new FormData();
  form.append("model", "veo3.1-fast");
  form.append("prompt", "A paper kite floats above a field.");
  form.append("seconds", "4");
  form.append("size", "1280x720");

  const createResponse = await fetch("https://api.cometapi.com/v1/videos", {
    method: "POST",
    headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
    body: form,
  });

  if (!createResponse.ok) {
    throw new Error(await createResponse.text());
  }

  const { id } = await createResponse.json();

  for (let attempt = 0; attempt < 60; attempt += 1) {
    const retrieveResponse = await fetch(`https://api.cometapi.com/v1/videos/${id}`, {
      headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
    });

    if (!retrieveResponse.ok) {
      throw new Error(await retrieveResponse.text());
    }

    const task = await retrieveResponse.json();
    if (["completed", "failed", "error"].includes(task.status)) {
      console.log(task);
      break;
    }
    await new Promise((resolve) => setTimeout(resolve, 5000));
  }
  ```
</CodeGroup>

## Explication du flux

La génération de vidéos Veo est asynchrone. L’endpoint de création accepte des données de formulaire multipart et renvoie immédiatement un ID de tâche. Interrogez l’endpoint de récupération jusqu’à ce que la tâche atteigne un état terminal, puis conservez l’URL de la vidéo finale ou les détails du fichier à partir de la réponse terminée.

Utilisez des durées courtes et la plus petite taille utile pour les premiers tests. Déplacez les ressources terminées vers votre propre stockage lorsque votre application a besoin de conservation.

## Paramètres courants

| Paramètre         | Utilisation                                                           |
| ----------------- | --------------------------------------------------------------------- |
| `model`           | model ID Veo. L’exemple de la référence API utilise `veo3.1-fast`.    |
| `prompt`          | Prompt textuel pour la tâche vidéo.                                   |
| `seconds`         | Champ de formulaire de durée. La référence documente `4`, `6` et `8`. |
| `size`            | Taille exacte `WxH`, comme `1280x720`.                                |
| `input_reference` | Fichier image optionnel de première image pour l’image-vers-vidéo.    |

## Dépannage / FAQ

<AccordionGroup>
  <Accordion title="La requête échoue avec un problème de type de contenu">
    Envoyez des données de formulaire multipart. N’envoyez pas les requêtes de création Veo en JSON.
  </Accordion>

  <Accordion title="L’interrogation prend plus de temps que prévu">
    Utilisez une boucle d’interrogation bornée, stockez l’ID de tâche et affichez un état en attente dans votre application au lieu de bloquer une requête web.
  </Accordion>

  <Accordion title="Comment contrôler le coût">
    Commencez avec une courte durée, une seule tâche et la plus petite taille acceptable. Utilisez les quotas de compte et l’estimation des coûts avant d’augmenter le nombre de tâches.
  </Accordion>
</AccordionGroup>

## Étapes suivantes

* Lisez la [référence API Create a Veo 3 video](/api/video/veo3/create).
* Interrogez avec [Retrieve a Veo 3 video](/api/video/veo3/retrieve).
* Trouvez les modèles vidéo Veo dans [Models](/fr/overview/models).
* Consultez [Use polling and webhooks for video generation](/fr/guides/webhook-and-polling-for-video-generation).
* Estimez le coût d’une tâche avec [Estimate request cost before calling a model](/fr/guides/how-to-estimate-cost-before-calling-a-model).