Name: Seedance 2.0 API: AI Video Generator with Audio, up to 4K
Brand: magicapi
SKU: api-magicapi-multimodal-video-generator-bytedance-seedance-2-0
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Multimodal Video Generator API (ByteDance Seedance 2.0)

## Overview
Seedance 2.0 is a multimodal video generation model from ByteDance. Its developer describes it as having native audio, multimodal reference inputs and intelligent duration control.

Describe the video in `prompt`. Optionally start from a first frame (`image`) and end on a `last_frame_image`, or guide the result with up to 9 `reference_images`, 3 `reference_videos` and 3 `reference_audios`, referred to in the prompt as `[Image1]`, `[Video1]` and `[Audio1]`. Choose a `duration` of up to 15 seconds (or `-1` to let the model decide), a `resolution` from `480p` to `4k` and an `aspect_ratio`. With `generate_audio` (on by default) the video comes with dialogue, sound effects and music. Each request returns the URL of one MP4 video.

## Features
- **Text to video**: generate a clip from a prompt of up to 4000 characters.
- **First and last frame**: start from `image` and optionally end on `last_frame_image`.
- **Reference inputs**: up to 9 `reference_images`, 3 `reference_videos` and 3 `reference_audios` for characters, style, motion transfer, editing and lip-sync.
- **Native audio**: `generate_audio` (default `true`) adds dialogue, sound effects and background music. Put spoken lines in double quotes in the prompt.
- **Duration control**: up to 15 seconds (default `5`), or `-1` to let the model choose.
- **Resolutions**: `480p`, `720p` (default), `1080p` and `4k` (10-bit H.265/HEVC).
- **Aspect ratios**: `16:9` (default), `4:3`, `1:1`, `3:4`, `9:16`, `21:9`, `9:21` or `adaptive`.

## Use Cases
1. **Short ads and social clips**: generate vertical or widescreen clips with sound from a script.
2. **Animating stills**: turn a product shot or illustration into a moving scene with `image`.
3. **Consistent characters**: keep a character or style across clips with `reference_images`.
4. **Motion transfer and video edits**: restyle or re-time an existing clip with `reference_videos`.
5. **Lip-synced scenes**: drive speech and timing with `reference_audios` plus a reference image or video.

## Visual Examples
### Example Input
A text-only request: a snowy cabin at night, 5 seconds at `480p` and `16:9`, without audio, with a fixed seed.

```json
{
  "seed": 99,
  "prompt": "A cozy cabin in a snowy forest at night, warm light glowing from the windows, gentle snowfall, camera slowly pushing in through the trees",
  "duration": 5,
  "resolution": "480p",
  "aspect_ratio": "16:9",
  "generate_audio": false
}
```

### Example Output
[Watch the example output](https://blog.api.market/wp-content/uploads/2026/10/seedance-2-0-output-5yv1prkm-api-market.mp4)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  | up to 4000 characters | Text prompt for video generation. Maximum 4000 characters; the developer recommends keeping prompts under 600 English words |
| `image` | string (URL) | No | none |  | Image URL (jpeg, png, gif or webp) used as the first frame for image-to-video generation. Cannot be combined with reference_images |
| `last_frame_image` | string (URL) | No | none |  | Image URL (jpeg, png, gif or webp) used as the last frame. Works only together with image. Cannot be combined with reference_images |
| `reference_images` | array of strings (URLs) | No | `[]` |  | Up to 9 reference image URLs for character consistency, style guidance and scene composition. Refer to them in the prompt as [Image1], [Image2] and so on. Cannot be used together with image or last_frame_image |
| `reference_videos` | array of strings (URLs) | No | `[]` |  | Up to 3 reference video URLs (15 seconds in total at most) for motion transfer, style reference and editing. Refer to them in the prompt as [Video1], [Video2] and so on. Sending at least one uses the higher-priced tier |
| `reference_audios` | array of strings (URLs) | No | `[]` |  | Up to 3 reference audio URLs (15 seconds in total at most) for audio-driven generation and lip-sync. Requires at least one reference image or video. Refer to them in the prompt as [Audio1], [Audio2] and so on |
| `duration` | integer | No | `5` | `-1` to `15` | Video duration in seconds. Set to -1 to let the model choose the length |
| `resolution` | string | No | `720p` | `480p`, `720p`, `1080p`, `4k` | Video resolution. 4k outputs 10-bit H.265/HEVC at a high bitrate |
| `aspect_ratio` | string | No | `16:9` | `16:9`, `4:3`, `1:1`, `3:4`, `9:16`, `21:9`, `9:21`, `adaptive` | Video aspect ratio. adaptive lets the model choose the ratio from the inputs |
| `generate_audio` | boolean | No | `true` |  | Generate synchronized audio with the video: dialogue (put spoken lines in double quotes in the prompt), sound effects and background music |
| `seed` | integer | No | none |  | Random seed. Set a value for reproducible generation |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.10 per API unit.
- **1 API unit = 1 second of output video, times the factor of the matching tier.** The request is billed on the length of the returned video, which matches `duration` when you set one; with `duration` set to `-1` it is the length the model chose. Each request is rounded up to a whole API unit.
- The tier depends on `resolution` and on whether `reference_videos` is non-empty. Price per second of video:

  | `resolution` | No reference videos | With reference videos |
  | --- | --- | --- |
  | `480p` | $0.10 (factor 1) | $0.125 (factor 1.25) |
  | `720p` | $0.225 (factor 2.25) | $0.275 (factor 2.75) |
  | `1080p` | $0.5625 (factor 5.625) | $0.6875 (factor 6.875) |
  | `4k` | $1.25 (factor 12.5) | $1.5625 (factor 15.625) |

- When the fields are omitted, `resolution` is `720p` and there are no reference videos, so the default price is **$0.225 per second** ($1.125 for the default 5 seconds). `generate_audio`, images and audio references do not change the price.
- **Example cost**: the example returned 5 seconds at 480p without reference videos: 5 x 1 = 5 API units = **$0.50**.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/multimodal-video-generator-bytedance-seedance-2-0`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 2 seconds and an overall timeout of 900 seconds (15 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/multimodal-video-generator-bytedance-seedance-2-0/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "bytedance/seedance-2.0",
    "input": {
      "seed": 99,
      "prompt": "A cozy cabin in a snowy forest at night, warm light glowing from the windows, gentle snowfall, camera slowly pushing in through the trees",
      "duration": 5,
      "resolution": "480p",
      "aspect_ratio": "16:9",
      "generate_audio": false
    }
  }'
```

Response (201 Created):
```json
{
  "id": "5yv1prkmjsrmy0d1cd4rdtqas0",
  "version": "bytedance/seedance-2.0",
  "status": "starting",
  "created_at": "2026-10-22T11:05:20.919Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/multimodal-video-generator-bytedance-seedance-2-0/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "5yv1prkmjsrmy0d1cd4rdtqas0",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/seedance-2-0-output-5yv1prkm-api-market.mp4",
  "error": null,
  "created_at": "2026-10-22T11:05:20.919Z",
  "started_at": "2026-10-22T11:05:20.933Z",
  "completed_at": "2026-10-22T11:07:32.733Z"
}
```

`output` is a single URL string pointing to the generated MP4 video.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `prompt`, a `duration` above 15, or `image` combined with `reference_images`.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/multimodal-video-generator-bytedance-seedance-2-0";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "bytedance/seedance-2.0", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 900000;
  const pollInterval = 2000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 15 minutes");
}

createAndWaitForPrediction({
    "seed": 99,
    "prompt": "A cozy cabin in a snowy forest at night, warm light glowing from the windows, gentle snowfall, camera slowly pushing in through the trees",
    "duration": 5,
    "resolution": "480p",
    "aspect_ratio": "16:9",
    "generate_audio": false
  }).then((output) => console.log(output));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/multimodal-video-generator-bytedance-seedance-2-0"


def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "bytedance/seedance-2.0", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])


def poll_for_results(prediction_id):
    max_timeout = 900
    poll_interval = 2
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 15 minutes")


print(create_and_wait_for_prediction({
    "seed": 99,
    "prompt": "A cozy cabin in a snowy forest at night, warm light glowing from the windows, gentle snowfall, camera slowly pushing in through the trees",
    "duration": 5,
    "resolution": "480p",
    "aspect_ratio": "16:9",
    "generate_audio": False
}))
```

## FAQ
- **Can I combine a first frame image with reference images?**
  - No. `image` and `last_frame_image` cannot be used together with `reference_images`. Use one approach per request.
- **How do I use reference audio?**
  - Send up to 3 clips (15 seconds in total) in `reference_audios` together with at least one reference image or video, and refer to them in the prompt as `[Audio1]`, `[Audio2]` and so on.
- **What does `duration: -1` do?**
  - The model picks the length itself. You are billed on the length of the video it returns.
- **Why does a request with reference videos cost more?**
  - Requests with at least one entry in `reference_videos` use the higher tier in the pricing table, for example $0.275 instead of $0.225 per second at 720p.
- **How long does generation take?**
  - Minutes rather than seconds. The 5-second 480p example took about 132 seconds, so poll every few seconds and allow up to 15 minutes.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us
If you have any questions, reach out to us through the chat on the bottom right of the page. You can also email our support team at hello@magicapi.com.


Generate 480p to 4K videos with synchronized audio from text, images, reference videos and audio with ByteDance's Seedance 2.0. Pay as you go, no monthly fee.