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

# Veo 3 API-snelstart: Genereer video's met CometAPI

> Maak een Veo-videotaak aan met CometAPI, poll de taakstatus en sla voltooide video-output op met curl, Python of Node.js.

## Wat je gaat bouwen

Je maakt één Veo-videotaak aan met multipart form data, slaat de geretourneerde taak-ID op, pollt de retrieve-endpoint en bewaart de uiteindelijke asset-URL of het bestand in je eigen systeem.

## Vereisten

* Een CometAPI API key opgeslagen in `COMETAPI_KEY`
* Python 3.10+ met `requests`, of Node.js 18+
* Een server-side job runner voor polling

## API key, basis-URL, authenticatie

Maak Veo-taken aan met:

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

Poll de status van Veo-taken met:

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

Authenticeer met een Bearer token:

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

## Codevoorbeelden

Gebruik de tabbladen hieronder voor kopieerbare voorbeelden in cURL, Python en 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>

## Uitleg van de flow

Veo-videogeneratie is asynchroon. De create-endpoint accepteert multipart form data en retourneert direct een taak-ID. Poll de retrieve-endpoint totdat de taak een terminale status bereikt, en sla daarna de definitieve video-URL of bestandsdetails uit de voltooide response op.

Gebruik korte duurinstellingen en de kleinst bruikbare grootte voor eerste tests. Verplaats voltooide assets naar je eigen opslag wanneer je applicatie retentie nodig heeft.

## Algemene parameters

| Parameter         | Gebruik                                                                  |
| ----------------- | ------------------------------------------------------------------------ |
| `model`           | Veo model ID. Het voorbeeld in de API-referentie gebruikt `veo3.1-fast`. |
| `prompt`          | Tekstprompt voor de videotaak.                                           |
| `seconds`         | Formulierveld voor de duur. De referentie documenteert `4`, `6` en `8`.  |
| `size`            | Exacte grootte `WxH`, zoals `1280x720`.                                  |
| `input_reference` | Optioneel afbeeldingsbestand voor het eerste frame voor image-to-video.  |

## Probleemoplossing / FAQ

<AccordionGroup>
  <Accordion title="De aanvraag mislukt met een probleem met het content type">
    Verstuur multipart form data. Verstuur Veo-create-aanvragen niet als JSON.
  </Accordion>

  <Accordion title="Polling duurt langer dan verwacht">
    Gebruik een begrensde polling-lus, sla de task ID op en toon een status in behandeling in je applicatie in plaats van een webaanvraag te blokkeren.
  </Accordion>

  <Accordion title="Hoe moet ik de kosten beheersen">
    Begin met een korte duur, één taak en de kleinste acceptabele grootte. Gebruik accountquota en kostenraming voordat je het aantal taken opschaalt.
  </Accordion>
</AccordionGroup>

## Volgende stappen

* Lees de [Create a Veo 3 video API reference](/api/video/veo3/create).
* Poll met [Retrieve a Veo 3 video](/api/video/veo3/retrieve).
* Vind Veo-videomodellen in [Models](/nl/overview/models).
* Bekijk [Use polling and webhooks for video generation](/nl/guides/webhook-and-polling-for-video-generation).
* Schat taakkosten in met [Estimate request cost before calling a model](/nl/guides/how-to-estimate-cost-before-calling-a-model).