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

# doubao-seedance-2.0 Videogenerierung

>  - Asynchroner Verarbeitungsmodus, gibt Task-ID für nachfolgende Abfragen zurück
- Unterstützt Text-zu-Video und Bild-zu-Video (erster Frame / letzter Frame)
- Unterstützt Referenzvideo, Referenzaudio und Video mit Audiospur
- Unterstützt Quer-, Hoch-, Quadrat-, Ultrabreit- und adaptives Format 

<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": "doubao-seedance-2.0",
      "prompt": "A kitten yawning at the camera",
      "resolution": "720p",
      "size": "16:9",
      "duration": 5,
      "generate_audio": true
    }'
  ```

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

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

  payload = {
      "model": "doubao-seedance-2.0",
      "prompt": "A kitten yawning at the camera",
      "resolution": "720p",
      "size": "16:9",
      "duration": 5,
      "generate_audio": True
  }

  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: "doubao-seedance-2.0",
    prompt: "A kitten yawning at the camera",
    resolution: "720p",
    size: "16:9",
    duration: 5,
    generate_audio: true
  };

  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":          "doubao-seedance-2.0",
          "prompt":         "A kitten yawning at the camera",
          "resolution":     "720p",
          "size":           "16:9",
          "duration":       5,
          "generate_audio": true,
      }

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

  ```java Java theme={null}
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;
  import java.net.URI;

  public class Main {
      public static void main(String[] args) throws Exception {
          String url = "https://api.apimart.ai/v1/videos/generations";

          String payload = """
          {
            "model": "doubao-seedance-2.0",
            "prompt": "A kitten yawning at the camera",
            "resolution": "720p",
            "size": "16:9",
            "duration": 5,
            "generate_audio": true
          }
          """;

          HttpClient client = HttpClient.newHttpClient();
          HttpRequest request = HttpRequest.newBuilder()
              .uri(URI.create(url))
              .header("Authorization", "Bearer <token>")
              .header("Content-Type", "application/json")
              .POST(HttpRequest.BodyPublishers.ofString(payload))
              .build();

          HttpResponse<String> response = client.send(request,
              HttpResponse.BodyHandlers.ofString());

          System.out.println(response.body());
      }
  }
  ```

  ```php PHP theme={null}
  <?php

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

  $payload = [
      "model" => "doubao-seedance-2.0",
      "prompt" => "A kitten yawning at the camera",
      "resolution" => "720p",
      "size" => "16:9",
      "duration" => 5,
      "generate_audio" => true
  ];

  $ch = curl_init($url);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_POST, true);
  curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
      "Authorization: Bearer <token>",
      "Content-Type: application/json"
  ]);

  $response = curl_exec($ch);
  curl_close($ch);

  echo $response;
  ?>
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'json'
  require 'uri'

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

  payload = {
    model: "doubao-seedance-2.0",
    prompt: "A kitten yawning at the camera",
    resolution: "720p",
    size: "16:9",
    duration: 5,
    generate_audio: true
  }

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true

  request = Net::HTTP::Post.new(url)
  request["Authorization"] = "Bearer <token>"
  request["Content-Type"] = "application/json"
  request.body = payload.to_json

  response = http.request(request)
  puts response.body
  ```

  ```swift Swift theme={null}
  import Foundation

  let url = URL(string: "https://api.apimart.ai/v1/videos/generations")!

  let payload: [String: Any] = [
      "model": "doubao-seedance-2.0",
      "prompt": "A kitten yawning at the camera",
      "resolution": "720p",
      "size": "16:9",
      "duration": 5,
      "generate_audio": true
  ]

  var request = URLRequest(url: url)
  request.httpMethod = "POST"
  request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
  request.setValue("application/json", forHTTPHeaderField: "Content-Type")
  request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

  let task = URLSession.shared.dataTask(with: request) { data, response, error in
      if let error = error {
          print("Error: \(error)")
          return
      }

      if let data = data, let responseString = String(data: data, encoding: .utf8) {
          print(responseString)
      }
  }

  task.resume()
  ```

  ```csharp C# theme={null}
  using System;
  using System.Net.Http;
  using System.Text;
  using System.Threading.Tasks;

  class Program
  {
      static async Task Main(string[] args)
      {
          var url = "https://api.apimart.ai/v1/videos/generations";

          var payload = @"{
              ""model"": ""doubao-seedance-2.0"",
              ""prompt"": ""A kitten yawning at the camera"",
              ""resolution"": ""720p"",
              ""size"": ""16:9"",
              ""duration"": 5,
              ""generate_audio"": true
          }";

          using var client = new HttpClient();
          client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");

          var content = new StringContent(payload, Encoding.UTF8, "application/json");
          var response = await client.PostAsync(url, content);
          var result = await response.Content.ReadAsStringAsync();

          Console.WriteLine(result);
      }
  }
  ```
</RequestExample>

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

  ```json 400 theme={null}
  {
    "error": {
      "code": 400,
      "message": "Invalid request parameters",
      "type": "invalid_request_error"
    }
  }
  ```

  ```json 401 theme={null}
  {
    "error": {
      "code": 401,
      "message": "Authentication failed, please check your API key",
      "type": "authentication_error"
    }
  }
  ```

  ```json 402 theme={null}
  {
    "error": {
      "code": 402,
      "message": "Insufficient account balance, please top up and try again",
      "type": "payment_required"
    }
  }
  ```

  ```json 429 theme={null}
  {
    "error": {
      "code": 429,
      "message": "Too many requests, please try again later",
      "type": "rate_limit_error"
    }
  }
  ```

  ```json 500 theme={null}
  {
    "error": {
      "code": 500,
      "message": "Internal server error, please try again later",
      "type": "server_error"
    }
  }
  ```
</ResponseExample>

## Authentifizierung

<ParamField header="Authorization" type="string" required>
  Alle API-Endpunkte erfordern eine Bearer-Token-Authentifizierung

  Holen Sie Ihren API Key:

  Besuchen Sie die [Seite zur API-Key-Verwaltung](https://apimart.ai/keys), um Ihren API Key zu erhalten

  Fügen Sie ihn dem Anfrage-Header hinzu:

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

## Anfrageparameter

<ParamField body="model" type="string" required>
  Name des Videogenerierungsmodells

  Unterstützte Modelle:

  * `doubao-seedance-2.0` — Standardversion, unterstützt Text-zu-Video, Bild-zu-Video, Video aus erstem/letztem Frame, Referenzvideo, Referenzaudio und Video mit Audiospur
  * `doubao-seedance-2.0-fast` — Schnellversion, dieselben Funktionen wie die Standardversion bei höherer Generierungsgeschwindigkeit
  * `doubao-seedance-2.0-mini` — Mini-Version, dieselben Funktionen wie die Standardversion
</ParamField>

<ParamField body="prompt" type="string">
  Beschreibung des Videoinhalts

  Erforderlich für Text-zu-Video; optional für Bild-zu-Video oder Video-Referenz-zu-Video

  Es wird empfohlen, Motiv, Aktion, Kamerabewegung und Stil klar anzugeben, um bessere Generierungsergebnisse zu erzielen

  <Warning>
    * Der Prompt ist auf 4000 Zeichen begrenzt, empfohlen werden jedoch 500 Zeichen.
    * Das Modell `doubao-seedance-2.0-mini` hat keine Zeichenbegrenzung. Empfehlung: Chinesische Prompts sollten 500 Zeichen und englische Prompts 1000 Wörter nicht überschreiten. Zu lange Texte führen leicht dazu, dass die Informationen verstreut werden, und das Modell könnte Details übersehen und sich nur auf die Schwerpunkte konzentrieren, wodurch im Video einige Elemente fehlen.
  </Warning>

  Beispiel: `"A kitten yawning at the camera"`
</ParamField>

<ParamField body="duration" type="integer" default="5">
  Videodauer (in Sekunden)

  Unterstützter Bereich: `4` bis `15` Sekunden

  Standard: `5`
</ParamField>

<ParamField body="size" type="string" default="16:9">
  Seitenverhältnis des Videos

  Optionen:

  * `16:9` — Querformat
  * `9:16` — Hochformat
  * `1:1` — Quadrat
  * `4:3` — Traditionelles Verhältnis
  * `3:4` — Vertikales traditionelles Verhältnis
  * `21:9` — Ultrabreit
  * `adaptive` — Adaptiv (passt sich automatisch an das eingegebene Bild/Video an)

  Standard: `16:9`
</ParamField>

<ParamField body="resolution" type="string" default="720p">
  Videoauflösung

  Optionen:

  * `480p` — Standard Definition
  * `720p` — High Definition
  * `1080p` — Full HD (nur unterstützt von `doubao-seedance-2.0`)
  * `4k` — Ultra HD (nur unterstützt von `doubao-seedance-2.0`)

  Standard: `720p`
</ParamField>

<ParamField body="seed" type="integer">
  Zufalls-Seed zur Steuerung der Zufälligkeit des generierten Inhalts

  <Note>
    * Bei derselben Anfrage erzeugen unterschiedliche Seed-Werte unterschiedliche Ergebnisse
    * Bei derselben Anfrage erzeugt derselbe Seed-Wert ähnliche Ergebnisse, exakte Konsistenz ist jedoch nicht garantiert
  </Note>
</ParamField>

<ParamField body="generate_audio" type="boolean" default="true">
  Ob Audio generiert werden soll (Video mit Audiospur)

  Wenn auf `true` gesetzt, enthält das Video von der KI generiertes Begleitaudio

  Standard: `true`
</ParamField>

<ParamField body="return_last_frame" type="boolean" default="false">
  Ob das Bild des letzten Frames zurückgegeben werden soll

  Wenn auf `true` gesetzt, gibt das Aufgabenergebnis zusätzlich die URL des letzten Frames des Videos zurück, die für die kontinuierliche Videogenerierung verwendet werden kann

  Standard: `false`
</ParamField>

<ParamField body="tools" type="array<object>">
  Werkzeugliste für erweiterte Funktionen wie Websuche

  Beispiel: `[{"type": "web_search"}]`

  <Expandable title="Feldbeschreibung">
    <ParamField body="type" type="string" required>
      Werkzeugtyp

      Optionen:

      * `web_search` — Websuche, bezieht Online-Informationen während der Generierung ein
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="image_urls" type="array<string>">
  Array von Bild-URLs für Bild-zu-Video

  Unterstützt zwei Formate:

  * Normale Bild-URL: `https://example.com/cat.jpg`
  * Asset-URL (genehmigtes Asset): `asset://asset_a`

  Beispiel: `["https://example.com/cat.jpg"]` oder `["asset://asset_a"]`

  <Note>
    Asset-URL wird nur von den Modellen `doubao-seedance-2.0` und `doubao-seedance-2.0-fast` unterstützt. Andere Modelle unterstützen sie nicht.
  </Note>

  <Warning>
    * `image_urls` und `image_with_roles` können nicht gleichzeitig verwendet werden
    * Maximal 9 Referenzbilder
  </Warning>
</ParamField>

<ParamField body="image_with_roles" type="array">
  Bild-Array mit Rollen, unterstützt die Angabe von erstem Frame/letztem Frame

  <Note>
    Wenn das Feld `url` eine Asset-URL verwendet, werden nur die Modelle `doubao-seedance-2.0` und `doubao-seedance-2.0-fast` unterstützt. Andere Modelle unterstützen sie nicht.
  </Note>

  <Expandable title="Feldbeschreibung">
    <ParamField body="url" type="string" required>
      Bild-URL

      Unterstützt zwei Formate:

      * Normale Bild-URL: `https://example.com/day.jpg`
      * Asset-URL (genehmigtes Asset): `asset://asset_a`

      <Note>
        Asset-URL wird nur von den Modellen `doubao-seedance-2.0` und `doubao-seedance-2.0-fast` unterstützt. Andere Modelle unterstützen sie nicht.
      </Note>
    </ParamField>

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

      Optionen:

      * `first_frame` — Bild des ersten Frames, wird als Startframe des Videos verwendet
      * `last_frame` — Bild des letzten Frames, wird als Endframe des Videos verwendet
      * `reference_image` — Referenz-Porträtbild (wird mit Asset-URL verwendet)
    </ParamField>
  </Expandable>

  Beispiel:

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

  Asset-URL-Format:

  ```json theme={null}
  [
    {"url": "asset://asset_a", "role": "reference_image"}
  ]
  ```

  <Warning>
    * `image_urls` und `image_with_roles` können nicht gleichzeitig verwendet werden
    * Bei Verwendung von Bildern des ersten/letzten Frames sind `video_urls` und `audio_urls` nicht verfügbar
  </Warning>
</ParamField>

<ParamField body="video_urls" type="array<string>">
  Array von Referenzvideo-URLs

  Unterstützt zwei Formate:

  * Normale Video-URL: `https://example.com/reference.mp4`
  * Asset-URL (genehmigtes Asset): `asset://asset_a`

  Beispiel: `["https://example.com/reference.mp4"]` oder `["asset://asset_a"]`

  <Note>
    Asset-URL wird nur von den Modellen `doubao-seedance-2.0` und `doubao-seedance-2.0-fast` unterstützt. Andere Modelle unterstützen sie nicht.
  </Note>

  <Warning>
    * Bei Verwendung von Bildern des ersten/letzten Frames (`image_with_roles`) sind Referenzvideos nicht verfügbar
    * Maximal 3 Referenzvideos, 1.8 s \< Gesamtdauer \< 15.2 s
    * Die Auflösung des Referenzvideos muss zwischen 480P und 720P liegen
    * Referenzvideos dürfen keine echten Personen enthalten
  </Warning>
</ParamField>

<ParamField body="audio_urls" type="array<string>">
  Array von Referenzaudio-URLs

  Unterstützt zwei Formate:

  * Normale Audio-URL: `https://example.com/speech.wav`
  * Asset-URL (genehmigtes Asset): `asset://asset_a`

  Beispiel: `["https://example.com/speech.wav"]` oder `["asset://asset_a"]`

  <Note>
    Asset-URL wird nur von den Modellen `doubao-seedance-2.0` und `doubao-seedance-2.0-fast` unterstützt. Andere Modelle unterstützen sie nicht.
  </Note>

  <Warning>
    * Bei Verwendung von Bildern des ersten/letzten Frames (`image_with_roles`) ist Referenzaudio nicht verfügbar
    * Maximal 3 Referenzaudiodateien, Gesamtdauer maximal 15 Sekunden
    * Referenzaudio muss zusammen mit Referenzbildern oder Referenzvideos verwendet werden
  </Warning>
</ParamField>

## Antwort

<ResponseField name="code" type="integer">
  Antwortstatuscode, 200 bei Erfolg
</ResponseField>

<ResponseField name="data" type="array">
  Array der Antwortdaten

  <Expandable title="Array-Elemente">
    <ResponseField name="status" type="string">
      Aufgabenstatus, `submitted` bei der ersten Einreichung
    </ResponseField>

    <ResponseField name="task_id" type="string">
      Eindeutige Aufgabenkennung zum Abfragen des Aufgabenstatus und der Ergebnisse
    </ResponseField>
  </Expandable>
</ResponseField>

## Anwendungsfälle

### Fall 1: Text-zu-Video

```json theme={null}
{
  "model": "doubao-seedance-2.0",
  "prompt": "A kitten yawning at the camera",
  "resolution": "720p",
  "size": "16:9",
  "duration": 5,
  "seed": 42,
  "generate_audio": true
}
```

### Fall 2: Bild-zu-Video (erster Frame)

```json theme={null}
{
  "model": "doubao-seedance-2.0",
  "prompt": "The kitten stands up and walks toward the camera",
  "image_urls": ["https://example.com/cat.jpg"],
  "duration": 5
}
```

### Fall 3: Video aus erstem/letztem Frame

```json theme={null}
{
  "model": "doubao-seedance-2.0",
  "prompt": "Transition from day to night",
  "image_with_roles": [
    {"url": "https://example.com/day.jpg", "role": "first_frame"},
    {"url": "https://example.com/night.jpg", "role": "last_frame"}
  ],
  "duration": 5
}
```

### Fall 4: Video aus Referenzvideo

```json theme={null}
{
  "model": "doubao-seedance-2.0",
  "prompt": "Convert the video style to anime style",
  "video_urls": ["https://example.com/reference.mp4"]
}
```

### Fall 5: Referenzvideo + Referenzaudio

```json theme={null}
{
  "model": "doubao-seedance-2.0",
  "prompt": "A scene of a person speaking",
  "video_urls": ["https://example.com/reference.mp4"],
  "audio_urls": ["https://example.com/speech.wav"],
  "size": "16:9",
  "duration": 11
}
```

### Fall 6: Video mit Audiospur

```json theme={null}
{
  "model": "doubao-seedance-2.0",
  "prompt": "A man stops a woman and says: \"Remember, you must never point your finger at the moon.\"",
  "generate_audio": true
}
```

### Fall 7: Kontinuierliche Videogenerierung (letzten Frame zurückgeben)

```json theme={null}
{
  "model": "doubao-seedance-2.0",
  "prompt": "The kitten continues walking toward the camera",
  "image_urls": ["https://example.com/last_frame_from_prev.png"],
  "return_last_frame": true
}
```

### Fall 8: Generierung mit Schnellversion

```json theme={null}
{
  "model": "doubao-seedance-2.0-fast",
  "prompt": "City nightscape timelapse photography",
  "size": "21:9",
  "duration": 8
}
```

### Fall 9: Referenzbilder + Referenzvideo + Referenzaudio (multimodales Video)

Kombinieren Sie Referenzbilder, Referenzvideo und Referenzaudio, um ein immersives Werbevideo aus der Ich-Perspektive zu erstellen. Ideal für Produktwerbung, Markenanzeigen und andere Szenarien, die das Zusammenführen von Materialien aus mehreren Quellen erfordern.

```json theme={null}
{
  "model": "doubao-seedance-2.0",
  "prompt": "Use video 1's first-person perspective throughout, and use audio 1 as the background music throughout. First-person POV fruit tea advertisement for seedance brand 'Peace Apple' apple fruit tea limited edition. First frame is image 1: your hand picks a dewy Aksu red apple with a crisp apple collision sound. 2-4s: quick cut, your hand drops apple chunks into a shaker cup, adds ice and tea base, shakes vigorously, ice collision and shaking sounds sync with upbeat drum beats, background voice: 'Fresh-cut, fresh-shaken'. 4-6s: first-person close-up of the finished product, layered fruit tea poured into a clear cup, your hand gently squeezes cream cap spreading on top, sticks a pink label on the cup, camera zooms in on the layered texture of cream cap and fruit tea. 6-8s: first-person handheld cup raise, you lift the fruit tea from image 2 toward the camera (simulating handing it to the viewer), cup label clearly visible, background voice 'Take a sip of freshness', final frame freezes on image 2. Background voice consistently uses a female tone.",
  "image_urls": [
    "https://example.com/tea_pic1.jpg",
    "https://example.com/tea_pic2.jpg"
  ],
  "video_urls": ["https://example.com/tea_video1.mp4"],
  "audio_urls": ["https://example.com/tea_audio1.mp3"],
  "generate_audio": true,
  "size": "16:9",
  "duration": 11
}
```

### Fall 10: Bild-zu-Video mit Asset-URL

Genehmigte Assets virtueller Avatare können direkt als Referenzbilder übergeben werden, ohne sie erneut hochladen oder prüfen lassen zu müssen.

```json theme={null}
{
  "model": "doubao-seedance-2.0",
  "prompt": "The character walks naturally on a city street under bright sunshine",
  "image_urls": ["asset://asset_a"],
  "duration": 5,
  "resolution": "720p"
}
```

### Fall 11: Referenz-Porträt mit Asset-URL angeben (image\_with\_roles)

```json theme={null}
{
  "model": "doubao-seedance-2.0",
  "prompt": "Using the reference portrait, the character walks elegantly toward the camera",
  "image_with_roles": [
    {
      "url": "asset://asset_a",
      "role": "reference_image"
    }
  ],
  "resolution": "720p",
  "duration": 5
}
```

### Fall 12: Schnellversion + Asset-URL für Bild-zu-Video

```json theme={null}
{
  "model": "doubao-seedance-2.0-fast",
  "prompt": "The character strolls in a park with a gentle breeze",
  "image_urls": ["asset://asset_a"],
  "duration": 5,
  "resolution": "720p"
}
```

### Fall 13: Bild über Asset-URL + Referenzvideo (Bewegungsübertragung)

Kombinieren Sie ein genehmigtes Porträt-Asset mit einem Referenzvideo, um die Figur dazu zu bringen, bestimmte Bewegungen auszuführen.

```json theme={null}
{
  "model": "doubao-seedance-2.0",
  "prompt": "The character dances to the rhythm of the reference video with smooth and natural movements",
  "image_urls": ["https://example.com/dance_reference.jpg", "asset://asset_a"],
  "video_urls": ["https://example.com/dance_reference.mp4", "asset://asset_a"],
  "duration": 8,
  "resolution": "720p"
}
```

<Note>
  **Aufgabenergebnisse abfragen**

  Die Videogenerierung ist eine asynchrone Aufgabe, die bei der Einreichung eine `task_id` zurückgibt. Verwenden Sie den Endpunkt [Aufgabenstatus abrufen](/de/api-reference/tasks/status), um den Fortschritt und die Ergebnisse der Generierung abzufragen.
</Note>

## Unterschiede zur Version 1.5 Pro

| Funktion                       | 1.5 Pro                           | 2.0 / 2.0 fast                                  |
| ------------------------------ | --------------------------------- | ----------------------------------------------- |
| Auflösung                      | 480p/720p/1080p                   | **480p/720p/1080p/4k** (fast nur 480p/720p)     |
| Dauerbereich                   | 4-12 s                            | **5-15 s**                                      |
| Standarddauer                  | 5 s                               | **5 s**                                         |
| Parameter für Seitenverhältnis | `aspect_ratio`                    | **`size`** (neue Option `adaptive`)             |
| Audio-Generierung              | Parameter `audio`                 | **Parameter `generate_audio`**                  |
| Referenzvideo                  | Nicht unterstützt                 | **Unterstützt über `video_urls`**               |
| Referenzaudio                  | Nicht unterstützt                 | **Unterstützt über `audio_urls`**               |
| Bild-zu-Video                  | `image_urls` / `image_with_roles` | **`image_urls` / `image_with_roles`**           |
| Video mit Audiospur            | Nicht unterstützt                 | **Unterstützt über `generate_audio`**           |
| Kontinuierliches Video         | Nicht unterstützt                 | **Unterstützt über `return_last_frame`**        |
| Schnellversion                 | Nicht unterstützt                 | **Unterstützt über `doubao-seedance-2.0-fast`** |