Name: Seedance 2.0 Fast API: AI Video Generator with Audio
Brand: magicapi
SKU: api-magicapi-fast-video-generation-api-bytedance-seedance-2-0-fast
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Fast Video Generator with Audio API (ByteDance Seedance 2.0 Fast)

## Overview
Seedance 2.0 Fast is ByteDance's faster variant of Seedance 2.0. Its developer describes it as built for quicker video generation with multimodal inputs and native audio.

Describe the video in `prompt` and the model returns an MP4 of up to 15 seconds at 480p or 720p. You can start from a first-frame `image` (with an optional `last_frame_image`), or guide the result with up to 9 `reference_images`, 3 `reference_videos` and 3 `reference_audios`, which you refer to in the prompt as [Image1], [Video1], [Audio1] and so on. With `generate_audio` on (default), the video includes dialogue, sound effects and background music.

## Features
- **Text-to-video**: generate a video from a `prompt` alone.
- **First and last frame**: `image` sets the first frame; `last_frame_image` sets the last frame when a first frame is given.
- **Reference inputs**: up to 9 reference images (characters, style, composition), up to 3 reference videos (motion transfer, style reference, editing) and up to 3 reference audio files (audio-driven generation and lip-sync), referenced in the prompt as [Image1], [Video1], [Audio1].
- **Native audio**: `generate_audio` (default `true`) adds synchronized dialogue, sound effects and music. Put spoken lines in double quotes in the prompt.
- **Length and format**: `duration` up to 15 seconds (default 5), or -1 for a length the model picks; `480p` or `720p` (default); aspect ratios `16:9` (default), `4:3`, `1:1`, `3:4`, `9:16`, `21:9`, `9:21` or `adaptive`.
- **Seed**: set `seed` for reproducible generation.

## Use Cases
1. **Social and marketing clips**: short vertical or widescreen videos with sound from a text brief.
2. **Animating stills**: turn a product shot or illustration into a moving scene with `image`, or define both ends with `last_frame_image`.
3. **Consistent characters**: keep a character or style across clips with `reference_images`.
4. **Motion and edits from video**: transfer motion or style from up to 3 `reference_videos`.
5. **Talking scenes**: drive speech and lip-sync from `reference_audios` together with a reference image or video.

## Visual Examples
### Example Input
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", 5 seconds at 480p, 16:9, with audio:

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

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

A 5-second 480p video of the snowy cabin with generated audio.

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes | none |  | Text prompt for video generation |
| `image` | string (URL) | No | none |  | Input image for image-to-video generation, used as the first frame (URL). Cannot be combined with reference images |
| `last_frame_image` | string (URL) | No | none |  | Input image for the last frame (URL). Only works if a first frame image is also provided. Cannot be combined with reference images |
| `reference_images` | array of URLs | No | `[]` |  | Reference images (up to 9) for character consistency, style guidance and scene composition. Cannot be used together with first or last frame images. Refer to them in your prompt as [Image1], [Image2], etc. |
| `reference_videos` | array of URLs | No | `[]` |  | Reference videos (up to 3, total duration max 15 s) for motion transfer, style reference and editing. Refer to them in your prompt as [Video1], [Video2], etc. |
| `reference_audios` | array of URLs | No | `[]` |  | Reference audio files (up to 3, total duration max 15 s) for audio-driven generation and lip-sync. Requires at least one reference image or video. Refer to them in your prompt as [Audio1], [Audio2], etc. |
| `duration` | integer | No | `5` | -1 to 15 | Video duration in seconds. Set to -1 to let the model pick the best length |
| `resolution` | string | No | `720p` | `480p`, `720p` | Video resolution |
| `aspect_ratio` | string | No | `16:9` | `16:9`, `4:3`, `1:1`, `3:4`, `9:16`, `21:9`, `9:21`, `adaptive` | Video aspect ratio. Set to adaptive to let the model choose the ratio based on the inputs |
| `generate_audio` | boolean | No | `true` |  | Generate synchronized audio with the video, including dialogue (put it in double quotes in the prompt), sound effects and background music |
| `seed` | integer | No | none |  | Random seed. Set it for reproducible generation |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.088 per API unit.
- **1 API unit = 1 second of 480p output video made without reference videos.** You are billed on the requested `duration`; with `duration` set to -1 (the model picks the length) you are billed on the length of the video it returns.
- 720p output and requests with `reference_videos` multiply the seconds by a factor. The units of a request are seconds x factor, rounded up to a whole unit:

| `reference_videos` | `resolution` | Factor | Price per second | 5-second video |
| --- | --- | --- | --- | --- |
| empty (default) | `480p` | 1 | $0.088 | $0.44 (5 units) |
| empty (default) | `720p` (default) | 2.143 | $0.188584 | $0.968 (11 units) |
| at least one video | `480p` | 1.143 | $0.100584 | $0.528 (6 units) |
| at least one video | `720p` (default) | 2.429 | $0.213752 | $1.144 (13 units) |

- When you omit `resolution` it is `720p`, so a request with only a `prompt` (5 seconds, 720p, no reference videos) costs $0.968 (11 units).
- `generate_audio`, `aspect_ratio`, input images and reference audio do not change the price.
- The example request below (5 seconds, 480p, no reference videos) cost $0.44 (5 units).
- **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/fast-video-generation-api-bytedance-seedance-2-0-fast`

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

Video generation takes longer than image generation: the example request took about 84 seconds. A polling interval of 2 seconds and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-video-generation-api-bytedance-seedance-2-0-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "bytedance/seedance-2.0-fast",
    "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": true
    }
  }'
```

Response (201 Created):
```json
{
  "id": "6qvqdknngsrmw0d1ccjv0922rc",
  "version": "bytedance/seedance-2.0-fast",
  "status": "starting",
  "created_at": "2026-10-22T10:26:18.257Z"
}
```

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

Response when the prediction has finished (200 OK):
```json
{
  "id": "6qvqdknngsrmw0d1ccjv0922rc",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/seedance-2-0-fast-output-6qvqdknn-api-market.mp4",
  "error": null,
  "created_at": "2026-10-22T10:26:18.257Z",
  "started_at": "2026-10-22T10:26:18.269Z",
  "completed_at": "2026-10-22T10:27:41.866Z"
}
```

`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 a `resolution` other than `480p` or `720p`.
- **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/fast-video-generation-api-bytedance-seedance-2-0-fast";

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-fast", 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 = 600000;
  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 10 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": true
  }).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/fast-video-generation-api-bytedance-seedance-2-0-fast"


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-fast", "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 = 600
    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 10 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": True
}))
```

## FAQ
- **How long can a video be?**
  - Up to 15 seconds. `duration` defaults to 5; set it to -1 to let the model choose the length.
- **Can I combine a first-frame image with reference images?**
  - No. `image` and `last_frame_image` cannot be combined with `reference_images`. Use one approach per request.
- **Why does adding a reference video cost more?**
  - Requests with at least one `reference_videos` entry use a higher factor: 1.143 at 480p and 2.429 at 720p, against 1 and 2.143 without one.
- **How do I use reference audio?**
  - Send up to 3 files in `reference_audios` (15 seconds in total) together with at least one reference image or video, and refer to them in the prompt as [Audio1], [Audio2].
- **Can I turn off audio?**
  - Yes. Set `generate_audio` to `false`. The price is the same with or without audio.
- **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 videos of up to 15 seconds with native audio from a prompt, a first frame, reference images, videos or audio with ByteDance Seedance 2.0 Fast.