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

# Gemini Omni 1.1 Flash Videogenerierung

>  - Googles offizielles multimodales All-in-One-Modell Gemini Omni 1.1 Flash zur Videogenerierung
- Unterstützt Text-zu-Video, Bild-zu-Video, Referenzen mehrerer Motive, Interpolation von Start- und Endbild, Videobearbeitung und -fortsetzung
- Unterstützt 360p / 720p / 1080p / 4K, 24 fps und 3–10 Sekunden lange Ausgaben mit generiertem Audio
- Asynchrone Aufgaben-API; Ergebnisse nach dem Senden über die Aufgaben-ID abrufen 

<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": "gemini-omni-1.1-flash",
      "prompt": "A marble rolling fast on a chain reaction style track, continuous smooth shot.",
      "aspect_ratio": "16:9",
      "resolution": "1080p"
    }'
  ```

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

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

  payload = {
      "model": "gemini-omni-1.1-flash",
      "prompt": "A marble rolling fast on a chain reaction style track, continuous smooth shot.",
      "aspect_ratio": "16:9",
      "resolution": "1080p"
  }

  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: "gemini-omni-1.1-flash",
    prompt: "A marble rolling fast on a chain reaction style track, continuous smooth shot.",
    aspect_ratio: "16:9",
    resolution: "1080p"
  };

  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":        "gemini-omni-1.1-flash",
          "prompt":       "A marble rolling fast on a chain reaction style track, continuous smooth shot.",
          "aspect_ratio": "16:9",
          "resolution":   "1080p",
      }

      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))
  }
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "code": 200,
    "data": [
      {
        "status": "submitted",
        "task_id": "task_01KS1H7ZYSJWH1N779S2FSHTKA"
      }
    ]
  }
  ```

  ```json 400 theme={null}
  {
    "error": {
      "code": 400,
      "message": "Ungültige Anfrageparameter",
      "type": "invalid_request_error"
    }
  }
  ```

  ```json 401 theme={null}
  {
    "error": {
      "code": 401,
      "message": "Authentifizierung fehlgeschlagen. Prüfen Sie Ihren API-Schlüssel",
      "type": "authentication_error"
    }
  }
  ```

  ```json 402 theme={null}
  {
    "error": {
      "code": 402,
      "message": "Kontoguthaben unzureichend. Laden Sie Guthaben auf und versuchen Sie es erneut",
      "type": "payment_required"
    }
  }
  ```

  ```json 429 theme={null}
  {
    "error": {
      "code": 429,
      "message": "Zu viele Anfragen. Versuchen Sie es später erneut",
      "type": "rate_limit_error"
    }
  }
  ```
</ResponseExample>

## Authentifizierung

<ParamField header="Authorization" type="string" required>
  Alle APIs erfordern die Authentifizierung mit einem Bearer Token.

  API-Schlüssel abrufen:

  Rufen Sie die [API-Schlüsselverwaltung](https://apimart.ai/keys) auf, um Ihren API-Schlüssel zu erhalten.

  Fügen Sie ihn dem Anfrageheader hinzu:

  ```
  Authorization: Bearer YOUR_API_KEY
  ```
</ParamField>

## Anfrageparameter

<ParamField body="model" type="string" required>
  Name des Videogenerierungsmodells. Muss `gemini-omni-1.1-flash` sein.
</ParamField>

<ParamField body="prompt" type="string">
  Textanweisung. Beschreiben Sie bei Text-zu-Video die Szene und bei Bild-zu-Video, Videobearbeitung oder -fortsetzung die Bewegung, den Stil oder die gewünschte Änderung.

  <Note>
    Geben Sie mindestens `prompt` oder Medien (`image_urls`, Start-/Endbilder oder `video_urls`) an.
  </Note>
</ParamField>

<ParamField body="resolution" type="string" default="720p">
  Auflösung des Ausgabevideos. Groß-/Kleinschreibung wird nicht berücksichtigt.

  Verfügbare Werte:

  * `360p`
  * `720p` (Standard)
  * `1080p`
  * `4k`

  `2160p` wird als `4k` behandelt. Die Auflösung bestimmt die Höhe der Vorabreservierung und die wesentlichen Kosten der Videoausgabe.

  <Warning>
    Eine nicht unterstützte Auflösung führt zum Fehler `invalid_resolution`.
  </Warning>
</ParamField>

<ParamField body="aspect_ratio" type="string" default="16:9">
  Seitenverhältnis des Videos zur Auswahl von Quer- oder Hochformat.

  Unterstützt:

  * `16:9` – Querformat (Standard)
  * `9:16` – Hochformat

  Andere Werte werden als `16:9` behandelt.

  <Warning>
    Wenn `video_urls` angegeben ist, übernimmt die Ausgabe normalerweise das Seitenverhältnis des Eingabevideos; `aspect_ratio` ist dann möglicherweise wirkungslos.
  </Warning>
</ParamField>

<ParamField body="image_urls" type="array<string>">
  Array mit Referenzbildern. Unterstützt werden nur öffentlich erreichbare HTTP/HTTPS-URLs.

  * 1 Bild: wird standardmäßig als Startbild des Videos verwendet
  * Mehrere Bilder: dienen als Motiv- oder Stilreferenzen; beschreiben Sie Zweck und Beziehung der Bilder in `prompt`

  <Warning>
    `image_urls` und Start-/Endbilder dürfen zusammen höchstens 10 Bilder enthalten.
  </Warning>
</ParamField>

<ParamField body="first_frame_image" type="string">
  Startbild. Unterstützt wird nur eine öffentlich erreichbare HTTP/HTTPS-URL.

  * Allein angegeben: verwendet das Bild als Startbild des Videos
  * Mit `last_frame_image` angegeben: erzeugt einen fließenden Übergang vom Start- zum Endbild
</ParamField>

<ParamField body="last_frame_image" type="string">
  Endbild. Unterstützt wird nur eine öffentlich erreichbare HTTP/HTTPS-URL; es muss zusammen mit `first_frame_image` angegeben werden.

  <Warning>
    Wird nur `last_frame_image` angegeben, wird `invalid_frame_images` zurückgegeben. Verwenden Sie für beide Bilder dasselbe Seitenverhältnis und stimmen Sie es auf `aspect_ratio` ab.
  </Warning>
</ParamField>

<Note>
  Für ein Startbild oder ein Start-/Endbildpaar sind die folgenden Methoden gleichwertig. **Wählen Sie eine davon und geben Sie nicht beide an**:

  * `first_frame_image` / `last_frame_image` verwenden
  * `image_with_roles` verwenden und `role` auf `first_frame` / `last_frame` setzen
</Note>

<ParamField body="image_with_roles" type="array<object>">
  Array mit Bildern und Rollen. Dies ist eine gleichwertige Alternative zu `first_frame_image` / `last_frame_image` und kann auch Referenzbilder deklarieren.

  <Expandable title="image_with_roles-Element">
    <ParamField body="url" type="string" required>
      Öffentlich erreichbare HTTP/HTTPS-URL des Bildes.
    </ParamField>

    <ParamField body="role" type="string" required>
      Bildrolle:

      * `first_frame`: Startbild
      * `last_frame`: Endbild; ein Startbild muss ebenfalls vorhanden sein
      * `reference`: Referenzbild; andere Rollen als Start- und Endbild werden ebenfalls als Referenz behandelt
    </ParamField>
  </Expandable>

  Beispiel:

  ```json theme={null}
  [
    {"url": "https://example.com/start.jpg", "role": "first_frame"},
    {"url": "https://example.com/end.jpg", "role": "last_frame"}
  ]
  ```

  <Note>
    Wenn zusätzlich `image_urls` angegeben ist, hat es für Referenzbilder Vorrang und wird nicht mit Referenzen in `image_with_roles` kombiniert. Insgesamt dürfen höchstens 10 Bilder einschließlich Start- und Endbild verwendet werden.
  </Note>
</ParamField>

<ParamField body="video_urls" type="array<string>">
  Array mit Videos zur Bearbeitung oder Fortsetzung. Derzeit ist höchstens ein Video mit maximal 10 Sekunden Länge erlaubt.

  Unterstützt werden nur öffentlich erreichbare direkte HTTP/HTTPS-Video-URLs. YouTube-Links werden nicht unterstützt.

  <Warning>
    `video_urls` und `extend_from_task_id` schließen sich gegenseitig aus. Geben Sie nur eines an.
  </Warning>
</ParamField>

<ParamField body="metadata" type="object">
  Objekt mit Zusatzparametern zur expliziten Angabe der Generierungsabsicht.

  <Expandable title="metadata-Felder">
    <ParamField body="task" type="string">
      Verfügbare Aufgabentypen:

      * `text_to_video`: Text-zu-Video
      * `image_to_video`: Bild-zu-Video
      * `reference_to_video`: Referenz-zu-Video
      * `edit`: Videobearbeitung
      * `extend`: Videofortsetzung

      Wenn nicht angegeben, leitet das System die Aufgabe aus Eingaben und Prompt ab.
    </ParamField>
  </Expandable>

  <Note>
    Bei der Interpolation von Start- und Endbild leitet das Modell den Aufgabentyp automatisch ab; die Plattform übergibt `metadata.task` nicht.
  </Note>
</ParamField>

<ParamField body="extend_from_task_id" type="string">
  Lokale `task_id` der vorherigen Generierungsaufgabe. Verwenden Sie sie für dialogbasierte Bearbeitung oder weitere Fortsetzung, ohne das vorherige Video erneut hochzuladen.

  Die referenzierte Aufgabe muss dem aktuellen Benutzer gehören, erfolgreich abgeschlossen sein und ein Gemini-Omni-Modell verwenden.

  <Warning>
    `extend_from_task_id` und `video_urls` schließen sich gegenseitig aus. Geben Sie nur eines an.
  </Warning>
</ParamField>

<Warning>
  Dieses Modell besitzt keinen Parameter `duration`. Die Dauer jeder Ausgabe wird inhaltsabhängig automatisch bestimmt und beträgt normalerweise 3–10 Sekunden. Beschreiben Sie das gewünschte Tempo in `prompt` in natürlicher Sprache oder mit Zeitbereichen.
</Warning>

## Antwort

<ResponseField name="code" type="integer">
  Antwortstatuscode. Bei Erfolg `200`.
</ResponseField>

<ResponseField name="data" type="array">
  Zurückgegebenes Aufgabenarray.

  <Expandable title="Array-Element">
    <ResponseField name="status" type="string">
      Anfangsstatus der Aufgabe. Bei erfolgreicher Übermittlung `submitted`.
    </ResponseField>

    <ResponseField name="task_id" type="string">
      Eindeutige Aufgaben-ID zum Abrufen von Status und Ergebnis.
    </ResponseField>
  </Expandable>
</ResponseField>

## Aufgabenergebnis abrufen

Die Videogenerierung läuft asynchron. Verwenden Sie nach Erhalt der `task_id` die API [Aufgabenstatus abrufen](/de/api-reference/tasks/status), um Fortschritt und Ergebnis abzufragen.

```bash cURL theme={null}
curl --request GET \
  --url https://api.apimart.ai/v1/tasks/task_01KS1H7ZYSJWH1N779S2FSHTKA \
  --header 'Authorization: Bearer <token>'
```

Fragen Sie alle 5–10 Sekunden ab und beenden Sie die Abfrage bei `completed` oder `failed`. Für den gesamten Client wird ein Timeout von 10 Minuten empfohlen.

### Beispiel für ein erfolgreiches Ergebnis

```json theme={null}
{
  "code": 200,
  "data": {
    "id": "task_01KS1H7ZYSJWH1N779S2FSHTKA",
    "status": "completed",
    "progress": 100,
    "cost": 1.52,
    "credits_cost": 15.2,
    "result": {
      "videos": [
        {
          "url": ["https://cdn.example.com/gemini_omni_xxx.mp4"],
          "expires_at": 1788518400
        }
      ]
    }
  }
}
```

## Anwendungsfälle

### Anwendungsfall 1: Text-zu-Video (4K)

```json theme={null}
{
  "model": "gemini-omni-1.1-flash",
  "prompt": "a blue butterfly landing on a flower, macro, soft light, no dialogue",
  "aspect_ratio": "9:16",
  "resolution": "4k"
}
```

### Anwendungsfall 2: Interpolation von Start- und Endbild

```json theme={null}
{
  "model": "gemini-omni-1.1-flash",
  "prompt": "smooth transition, camera slowly pushes in",
  "first_frame_image": "https://example.com/start.jpg",
  "last_frame_image": "https://example.com/end.jpg",
  "resolution": "720p"
}
```

### Anwendungsfall 3: Referenzen mehrerer Motive

```json theme={null}
{
  "model": "gemini-omni-1.1-flash",
  "prompt": "the cat playfully bats at the ball of yarn",
  "image_urls": [
    "https://example.com/cat.png",
    "https://example.com/yarn.png"
  ],
  "resolution": "720p"
}
```

### Anwendungsfall 4: Start- und Endbild über Bildrollen

```json theme={null}
{
  "model": "gemini-omni-1.1-flash",
  "prompt": "a smooth cinematic transition from sunrise to a starry night",
  "image_with_roles": [
    {"url": "https://example.com/sunrise.jpg", "role": "first_frame"},
    {"url": "https://example.com/night.jpg", "role": "last_frame"}
  ],
  "resolution": "1080p"
}
```

### Anwendungsfall 5: Videobearbeitung

```json theme={null}
{
  "model": "gemini-omni-1.1-flash",
  "prompt": "Make the violin invisible. Keep everything else the same.",
  "video_urls": ["https://example.com/clip.mp4"]
}
```

Verwenden Sie für die Videobearbeitung kurze, eindeutige Prompts. Wenn nur ein Teil geändert werden soll, fügen Sie `Keep everything else the same` hinzu, um den übrigen Inhalt konsistent zu halten.

### Anwendungsfall 6: Dialogbasierte Fortsetzung

```json theme={null}
{
  "model": "gemini-omni-1.1-flash",
  "prompt": "Extend this video: the camera pans across the mountains.",
  "extend_from_task_id": "task_01AAA"
}
```