> ## 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-Schnellstart: Videos mit CometAPI generieren

> Erstellen Sie mit CometAPI eine Veo-Videotask, fragen Sie den Task-Status per Polling ab und speichern Sie die abgeschlossene Videoausgabe mit curl, Python oder Node.js.

## Was Sie erstellen werden

Sie erstellen eine Veo-Videotask mit Multipart-Formulardaten, speichern die zurückgegebene Task-ID, fragen den Retrieve-Endpunkt per Polling ab und speichern die endgültige Asset-URL oder Datei in Ihrem eigenen System.

## Voraussetzungen

* Ein CometAPI API-Schlüssel, gespeichert in `COMETAPI_KEY`
* Python 3.10+ mit `requests` oder Node.js 18+
* Einen serverseitigen Job-Runner für Polling

## API-Schlüssel, Basis-URL, Authentifizierung

Erstellen Sie Veo-Tasks mit:

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

Fragen Sie den Status von Veo-Tasks ab mit:

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

Authentifizieren Sie sich mit einem Bearer-Token:

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

## Codebeispiele

Verwenden Sie die Tabs unten für kopierbare Beispiele in cURL, Python und 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>

## Erklärung des Ablaufs

Die Generierung von Veo-Videos ist asynchron. Der Create-Endpunkt akzeptiert Multipart-Formulardaten und gibt sofort eine Task-ID zurück. Fragen Sie den Retrieve-Endpunkt per Polling ab, bis der Task einen Endstatus erreicht, und persistieren Sie dann die endgültige Video-URL oder Dateidetails aus der abgeschlossenen Antwort.

Verwenden Sie für erste Tests kurze Dauern und die kleinste sinnvolle Größe. Verschieben Sie abgeschlossene Assets in Ihren eigenen Speicher, wenn Ihre Anwendung eine Aufbewahrung benötigt.

## Allgemeine Parameter

| Parameter         | Verwendung                                                              |
| ----------------- | ----------------------------------------------------------------------- |
| `model`           | Veo model ID. Das Beispiel in der API-Referenz verwendet `veo3.1-fast`. |
| `prompt`          | Text-Prompt für den Video-Job.                                          |
| `seconds`         | Formularfeld für die Dauer. Die Referenz dokumentiert `4`, `6` und `8`. |
| `size`            | Exakte `WxH`-Größe, z. B. `1280x720`.                                   |
| `input_reference` | Optionale Bilddatei für den ersten Frame bei image-to-video.            |

## Fehlerbehebung / FAQ

<AccordionGroup>
  <Accordion title="Die Anfrage schlägt mit einem Content-Type-Problem fehl">
    Senden Sie Multipart-Formulardaten. Senden Sie Veo-Erstellungsanfragen nicht als JSON.
  </Accordion>

  <Accordion title="Polling dauert länger als erwartet">
    Verwenden Sie eine begrenzte Polling-Schleife, speichern Sie die task ID und zeigen Sie in Ihrer Anwendung einen ausstehenden Status an, anstatt eine Webanfrage zu blockieren.
  </Accordion>

  <Accordion title="Wie sollte ich die Kosten steuern">
    Beginnen Sie mit einer kurzen Dauer, einer task und der kleinsten akzeptablen Größe. Verwenden Sie Konto-Quoten und eine Kostenschätzung, bevor Sie die Anzahl der tasks skalieren.
  </Accordion>
</AccordionGroup>

## Nächste Schritte

* Lesen Sie die [API-Referenz zum Erstellen eines Veo 3-Videos](/api/video/veo3/create).
* Fragen Sie den Status mit [Ein Veo 3-Video abrufen](/api/video/veo3/retrieve) ab.
* Finden Sie Veo-Videomodelle unter [Models](/de/overview/models).
* Lesen Sie [Polling und Webhooks für die Videogenerierung verwenden](/de/guides/webhook-and-polling-for-video-generation).
* Schätzen Sie die task-Kosten mit [Anfragekosten vor dem Aufruf eines Modells schätzen](/de/guides/how-to-estimate-cost-before-calling-a-model).