> ## 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 Sora 2 : générer des vidéos avec CometAPI

> Créez une tâche vidéo Sora 2 avec CometAPI, vérifiez son statut par interrogation, et téléchargez le contenu vidéo terminé avec curl, Python ou Node.js.

## Ce que vous allez créer

Vous allez soumettre une tâche vidéo Sora 2, stocker l’ID de vidéo renvoyé, interroger jusqu’à ce que la tâche soit terminée, puis télécharger le contenu vidéo final.

## Prérequis

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

## Clé API, URL de base, authentification

Créez des tâches Sora avec :

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

Interrogez le statut avec :

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

Téléchargez le contenu terminé avec :

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

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=sora-2 \
    -F "prompt=A paper boat drifts across a calm pond at sunrise" \
    -F seconds=4 \
    -F size=1280x720

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

  curl "https://api.cometapi.com/v1/videos/<video_id>/content" \
    -H "Authorization: Bearer $COMETAPI_KEY" \
    --output sora-result.mp4
  ```

  ```python Python theme={null}
  import os
  import time
  from pathlib import Path

  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,
      data={
          "model": "sora-2",
          "prompt": "A paper boat drifts across a calm pond at sunrise",
          "seconds": "4",
          "size": "1280x720",
      },
      timeout=60,
  )
  create_response.raise_for_status()
  video_id = create_response.json()["id"]

  for _ in range(60):
      status_response = requests.get(
          f"https://api.cometapi.com/v1/videos/{video_id}",
          headers=headers,
          timeout=30,
      )
      status_response.raise_for_status()
      status = status_response.json()
      if status["status"] == "completed":
          content_response = requests.get(
              f"https://api.cometapi.com/v1/videos/{video_id}/content",
              headers=headers,
              timeout=120,
          )
          content_response.raise_for_status()
          Path("sora-result.mp4").write_bytes(content_response.content)
          break
      if status["status"] == "failed":
          raise RuntimeError(status)
      time.sleep(5)
  else:
      raise TimeoutError("Sora job did not finish in time")
  ```

  ```javascript Node.js theme={null}
  import fs from "node:fs/promises";

  const form = new FormData();
  form.append("model", "sora-2");
  form.append("prompt", "A paper boat drifts across a calm pond at sunrise");
  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 statusResponse = await fetch(`https://api.cometapi.com/v1/videos/${id}`, {
      headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
    });

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

    const status = await statusResponse.json();
    if (status.status === "completed") {
      const contentResponse = await fetch(
        `https://api.cometapi.com/v1/videos/${id}/content`,
        { headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` } },
      );
      const videoBuffer = Buffer.from(await contentResponse.arrayBuffer());
      await fs.writeFile("sora-result.mp4", videoBuffer);
      break;
    }
    if (status.status === "failed") {
      throw new Error(JSON.stringify(status));
    }
    await new Promise((resolve) => setTimeout(resolve, 5000));
  }
  ```
</CodeGroup>

## Explication du flux

La génération Sora est asynchrone. Le endpoint de création renvoie un ID de vidéo et un statut initial. Interrogez `GET /v1/videos/<video_id>` jusqu’à ce que `status` soit `completed` ou `failed`. Lorsque la tâche est terminée, téléchargez le fichier avec `GET /v1/videos/<video_id>/content`.

Utilisez des tailles exactes au format `WxH`. La référence de l’API Sora documente les tailles paysage et portrait standard, ainsi que des tailles Pro plus grandes pour les workflows du modèle Pro.

## Paramètres courants

| Paramètre         | Utilisation                                                                  |
| ----------------- | ---------------------------------------------------------------------------- |
| `model`           | model ID Sora. L’exemple de référence utilise `sora-2`.                      |
| `prompt`          | Prompt textuel pour la vidéo.                                                |
| `seconds`         | Durée du clip. La référence de l’API documente `4`, `8`, `12`, `16` et `20`. |
| `size`            | Taille de sortie exacte `WxH`, par exemple `1280x720` ou `720x1280`.         |
| `input_reference` | Fichier image de référence facultatif pour les workflows de première image.  |

## Résolution des problèmes / FAQ

<AccordionGroup>
  <Accordion title="La requête de création échoue">
    Utilisez des données de formulaire multipart. Les requêtes de création Sora dans la référence utilisent des champs de formulaire, et non un corps JSON.
  </Accordion>

  <Accordion title="Le téléchargement du contenu échoue">
    Téléchargez le contenu uniquement après que l’endpoint de statut a indiqué `completed`. Stockez le fichier finalisé dans votre propre espace de stockage.
  </Accordion>

  <Accordion title="Une taille Pro ne fonctionne pas">
    Utilisez les grandes tailles Pro uniquement avec un workflow de modèle Pro. Commencez par `1280x720` pour une première requête.
  </Accordion>
</AccordionGroup>

## Étapes suivantes

* Consultez la [référence de l’API Create a Sora 2 video](/api/video/sora-2/create).
* Interrogez avec [Retrieve a Sora 2 video](/api/video/sora-2/retrieve).
* Téléchargez avec [Retrieve Sora 2 video content](/api/video/sora-2/retrieve-content).
* Trouvez les modèles vidéo disponibles 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).