> ## 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 Video Generation

>  - Async processing mode, returns task ID for subsequent queries
- Supports text-to-video, image-to-video (first frame/last frame)
- Supports reference video, reference audio, audio-enabled video
- Supports landscape, portrait, square, ultra-wide, and adaptive aspect ratios 

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

## Authentication

<ParamField header="Authorization" type="string" required>
  All API endpoints require Bearer Token authentication

  Get your API Key:

  Visit the [API Key Management Page](https://apimart.ai/keys) to get your API Key

  Add it to the request header:

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

## Request Parameters

<ParamField body="model" type="string" required>
  Video generation model name

  Supported models:

  * `doubao-seedance-2.0` - Standard version, supports text-to-video, image-to-video, first/last frame video, reference video, reference audio, and audio-enabled video
  * `doubao-seedance-2.0-fast` - Fast version, same features as the standard version with faster generation speed
  * `doubao-seedance-2.0-face` - Supports real person uploads, same features as the standard version
  * `doubao-seedance-2.0-fast-face` - Supports real person uploads, same features as the fast version
  * `doubao-seedance-2.0-mini` - Mini version, same features as the standard version
</ParamField>

<ParamField body="prompt" type="string">
  Video content description

  Required for text-to-video; optional for image-to-video or video-reference-to-video

  It is recommended to clearly specify the subject, action, camera movement, and style for better generation results

  <Warning>
    * The prompt is limited to 4000 characters, but 500 characters are recommended.
    * The model `doubao-seedance-2.0-mini` has no character limit. Recommendation: keep Chinese prompts under 500 characters and English prompts under 1000 words. Excessive length tends to disperse the information, and the model may overlook details and focus only on the key points, resulting in some elements being missing from the video.
  </Warning>

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

<ParamField body="duration" type="integer" default="5">
  Video duration (seconds)

  Supported range: `4` to `15` seconds

  Default: `5`
</ParamField>

<ParamField body="size" type="string" default="16:9">
  Video aspect ratio

  Options:

  * `16:9` - Landscape
  * `9:16` - Portrait
  * `1:1` - Square
  * `4:3` - Traditional ratio
  * `3:4` - Vertical traditional ratio
  * `21:9` - Ultra-wide
  * `adaptive` - Adaptive (automatically matches the input image/video)

  Default: `16:9`
</ParamField>

<ParamField body="resolution" type="string" default="720p">
  Video resolution

  Options:

  * `480p` - Standard definition
  * `720p` - High definition
  * `1080p` - Full HD (only supported by `doubao-seedance-2.0-face` and `doubao-seedance-2.0`)
  * `4k` - Ultra HD (only supported by `doubao-seedance-2.0`)

  Default: `720p`
</ParamField>

<ParamField body="seed" type="integer">
  Random seed for controlling the randomness of generated content

  <Note>
    * With the same request, different seed values will produce different results
    * With the same request, the same seed value will produce similar results, but exact consistency is not guaranteed
  </Note>
</ParamField>

<ParamField body="generate_audio" type="boolean" default="false">
  Whether to generate audio (audio-enabled video)

  When set to `true`, the video will include AI-generated accompanying audio

  Default: `false`
</ParamField>

<ParamField body="return_last_frame" type="boolean" default="false">
  Whether to return the last frame image

  When set to `true`, the task result will additionally return the URL of the video's last frame image, which can be used for continuous video generation

  Default: `false`
</ParamField>

<ParamField body="tools" type="array<object>">
  Tool list for enhanced capabilities such as web search

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

  <Expandable title="Field Description">
    <ParamField body="type" type="string" required>
      Tool type

      Options:

      * `web_search` - Web search, references online information during generation
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="image_urls" type="array<string>">
  Image URL array for image-to-video

  Supports two formats:

  * Regular image URL: `https://example.com/cat.jpg`
  * Asset URL (approved asset): `asset://asset_a`

  Example: `["https://example.com/cat.jpg"]` or `["asset://asset_a"]`

  <Note>
    Asset URL is only supported by `doubao-seedance-2.0` and `doubao-seedance-2.0-fast` models. Other models do not support it.
  </Note>

  <Warning>
    * `image_urls` and `image_with_roles` cannot be used simultaneously
    * Maximum of 9 reference images
  </Warning>
</ParamField>

<ParamField body="image_with_roles" type="array">
  Image array with roles, supports specifying first frame/last frame

  <Note>
    When the `url` field uses an Asset URL, only `doubao-seedance-2.0` and `doubao-seedance-2.0-fast` models are supported. Other models do not support it.
  </Note>

  <Expandable title="Field Description">
    <ParamField body="url" type="string" required>
      Image URL

      Supports two formats:

      * Regular image URL: `https://example.com/day.jpg`
      * Asset URL (approved asset): `asset://asset_a`

      <Note>
        Asset URL is only supported by `doubao-seedance-2.0` and `doubao-seedance-2.0-fast` models. Other models do not support it.
      </Note>
    </ParamField>

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

      Options:

      * `first_frame` - First frame image, used as the video's starting frame
      * `last_frame` - Last frame image, used as the video's ending frame
      * `reference_image` - Reference portrait image (used with Asset URL)
    </ParamField>
  </Expandable>

  Example:

  ```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` and `image_with_roles` cannot be used simultaneously
    * When using first/last frame images, `video_urls` and `audio_urls` are not available
  </Warning>
</ParamField>

<ParamField body="video_urls" type="array<string>">
  Reference video URL array

  Supports two formats:

  * Regular video URL: `https://example.com/reference.mp4`
  * Asset URL (approved asset): `asset://asset_a`

  Example: `["https://example.com/reference.mp4"]` or `["asset://asset_a"]`

  <Note>
    Asset URL is only supported by `doubao-seedance-2.0` and `doubao-seedance-2.0-fast` models. Other models do not support it.
  </Note>

  <Warning>
    * When using first/last frame images (`image_with_roles`), reference videos are not available
    * Maximum of 3 reference videos, 1.8s \< total duration \< 15.2s
    * Reference video resolution must be between 480P and 720P
    * Reference videos must not contain real people
  </Warning>
</ParamField>

<ParamField body="audio_urls" type="array<string>">
  Reference audio URL array

  Supports two formats:

  * Regular audio URL: `https://example.com/speech.wav`
  * Asset URL (approved asset): `asset://asset_a`

  Example: `["https://example.com/speech.wav"]` or `["asset://asset_a"]`

  <Note>
    Asset URL is only supported by `doubao-seedance-2.0` and `doubao-seedance-2.0-fast` models. Other models do not support it.
  </Note>

  <Warning>
    * When using first/last frame images (`image_with_roles`), reference audio is not available
    * Maximum of 3 reference audio files, total duration must be 15s or less
    * Reference audio must be used together with reference images or reference videos
  </Warning>
</ParamField>

## Response

<ResponseField name="code" type="integer">
  Response status code, 200 on success
</ResponseField>

<ResponseField name="data" type="array">
  Response data array

  <Expandable title="Array Elements">
    <ResponseField name="status" type="string">
      Task status, `submitted` when initially submitted
    </ResponseField>

    <ResponseField name="task_id" type="string">
      Unique task identifier for querying task status and results
    </ResponseField>
  </Expandable>
</ResponseField>

## Use Cases

### Case 1: Text-to-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
}
```

### Case 2: Image-to-Video (First 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
}
```

### Case 3: First/Last Frame Video

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

### Case 4: Video-Reference-to-Video

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

### Case 5: Reference Video + Reference Audio

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

### Case 6: Audio-Enabled Video

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

### Case 7: Continuous Video Generation (Return Last Frame)

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

### Case 8: Fast Version Generation

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

### Case 9: Reference Images + Reference Video + Reference Audio (Multi-Modal Video)

Combine reference images, reference video, and reference audio to generate an immersive first-person perspective advertisement video. Ideal for product promotions, brand ads, and other scenarios requiring multi-source material fusion.

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

### Case 10: Image-to-Video with Asset URL

Approved virtual avatar assets can be passed directly as reference images without re-uploading or re-reviewing.

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

### Case 11: Specify Reference Portrait with Asset URL (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
}
```

### Case 12: Fast Version + Asset URL Image-to-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"
}
```

### Case 13: Asset URL Image + Reference Video (Motion Transfer)

Combine an approved portrait asset with a reference video to drive the character to perform specified movements.

```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>
  **Query Task Results**

  Video generation is an async task that returns a `task_id` upon submission. Use the [Get Task Status](/en/api-reference/tasks/status) endpoint to query generation progress and results.
</Note>

## Differences from 1.5 Pro Version

| Feature                | 1.5 Pro                           | 2.0 / 2.0 fast                               |
| ---------------------- | --------------------------------- | -------------------------------------------- |
| Resolution             | 480p/720p/1080p                   | **480p/720p/1080p/4k** (fast only 480p/720p) |
| Duration range         | 4-12s                             | **5-15s**                                    |
| Default duration       | 5s                                | **5s**                                       |
| Aspect ratio parameter | `aspect_ratio`                    | **`size`** (new `adaptive` option)           |
| Audio generation       | `audio` parameter                 | **`generate_audio` parameter**               |
| Reference video        | Not supported                     | **Supported via `video_urls`**               |
| Reference audio        | Not supported                     | **Supported via `audio_urls`**               |
| Image-to-video         | `image_urls` / `image_with_roles` | **`image_urls` / `image_with_roles`**        |
| Audio-enabled video    | Not supported                     | **Supported via `generate_audio`**           |
| Continuous video       | Not supported                     | **Supported via `return_last_frame`**        |
| Fast version           | Not supported                     | **Supported via `doubao-seedance-2.0-fast`** |