# Seedance 2.0 Fast

Source: https://funnyai.io/models/seedance-2-0-fast

Create a short scene with Seedance 2.0 Fast using text, images or media references. Choose 480p or 720p output, with optional generated sound. Prepare the action in the Playground and inspect the current estimate before adding this model to your application.

Prepare a Fast request and inspect its estimate. Generation requires sign-in, available service and sufficient balance.

## What is Seedance 2.0 Fast?

Seedance 2.0 Fast is a separate ByteDance video model for clips between four and fifteen seconds, with automatic duration also available. It offers 480p and 720p output with optional sound. You can start with text, establish a composition with frames or bring reference material for the subject and movement.

A small product rotation is one way to evaluate Seedance 2.0 Fast. Define the starting angle, the amount of the turn and a camera position that stays fixed, then watch whether the object remains recognizable. Record completion time separately from visual quality; the model name is not a measured speed promise on Funny AI.

Seedance 2.0 Fast accepts up to 9 reference images, 3 videos and 3 audio clips. Reference video and reference audio each have a separate fifteen-second total.

- Single generation: up to 15 seconds
- Output options: 480p, 720p; model version and input-mode restrictions apply.
- References: 9 images, 3 video clips, 3 audio clips.

## Scene study: a shoe on a turntable

Scene illustration generated with Wan 3.0 · 5 seconds · 480p · silent. This is not Seedance 2.0 Fast output.

Prompt: A single unbranded yellow running shoe turns slowly on a small circular white display stand. Rounded lavender and peach blocks form a clean studio background. Soft high-key light reveals the fabric and sole as the shoe rotates a quarter turn. Stable side-on product framing, one continuous five-second shot. No lettering, no logo, no watermark.

The turntable illustration gives you a focused brief to adapt for Seedance 2.0 Fast: one shoe turns against a stable background. Inspect the outline and laces throughout the rotation. The displayed Wan 3.0 clip does not measure this variant’s output quality or completion time.

[Sample video](https://funnyai.io/media/funny-ai/2026-10-18/seedance-2-0-fast/video.mp4)

## Price the movement test

Seedance 2.0 Fast has its own live token rates. The table shows per-second estimates for 16:9 output at 24 fps, helping you compare the settings for a short motion test.

Reference video adds billable input to Seedance 2.0 Fast and can introduce a minimum usage threshold. Match length, resolution and references when comparing estimates; silent output does not use a separate lower token rate.

Estimates use 16:9 output at 24 fps. Other aspect ratios and actual output dimensions can change the cost.
Without reference video, only output seconds count. With reference video, input and output seconds count; billable input time is at least two-thirds of the output duration, rounded up to a whole second.
- 480p: approximately $0.0506 / billable second without reference video; $0.0298 with reference video. Official comparison: $0.0562 and $0.0331, respectively. Underlying rates: $5.04 / 1M video tokens without reference video; $2.97 with reference video.
- 720p: approximately $0.1089 / billable second without reference video; $0.0642 with reference video. Official comparison: $0.1210 and $0.0713, respectively. Underlying rates: $5.04 / 1M video tokens without reference video; $2.97 with reference video.

## Prepare the motion test

### Try the movement in your browser

Prepare Seedance 2.0 Fast in the Playground and inspect its input settings. Check current availability and the estimate before submitting the scene you want to test.

### Use Seedance 2.0 Fast in your app

Select the Seedance 2.0 Fast identifier in your code and follow its API guide. Save the returned task ID with the request for later status checks and result retrieval.

## Direct a focused movement

### Set the Seedance 2.0 Fast duration

Use four to fifteen seconds for a Seedance 2.0 Fast shot, or choose automatic duration. Keep one movement readable from beginning to end before building a brief with more events.

### Set the visual endpoints

Supply Seedance 2.0 Fast with a first frame and, optionally, a last frame. Use this mode when the opening and destination matter more than a collection of separate examples.

### Separate the subject from the movement

In Seedance 2.0 Fast reference mode, an image can describe the subject while video suggests its motion. Name each source’s role in the prompt to keep the direction clear.

### Include sound in the brief

Request generated sound with Seedance 2.0 Fast, or disable it for a later edit. An audio reference requires an accompanying reference image or video; the soundtrack should be reviewed with the picture.

## Short scenes with one clear action

### A product turning toward the viewer

Give Seedance 2.0 Fast a modest rotation to explore, with a fixed background and camera. The outline, material and small details provide specific points to check throughout the movement.

### A detail entering the frame

Use Seedance 2.0 Fast to explore a short reveal: an object moves into view or the camera passes an edge. Describe which element moves so the direction is easy to judge.

### An insert for a social edit

Create a Seedance 2.0 Fast shot that carries one visual idea within a larger sequence. Choose the intended aspect ratio and plan an ending that can connect to the next clip.

## Prepare a matched motion test

### Name the movement

Tell Seedance 2.0 Fast what the subject does and where the camera sits. Replace vague energy instructions with a visible action you can assess.

### Choose the right anchor

Use frames with Seedance 2.0 Fast for defined endpoints, or references when appearance and motion come from different files. Keep those input modes separate.

### Keep the comparison consistent

Match Seedance 2.0 Fast and Mini settings when evaluating the same brief. Hold the length, resolution and source material steady, then compare the complete results.

### Review picture and time separately

Save the Seedance 2.0 Fast task and watch the entire clip. Record elapsed time separately so a pleasing image does not become an unsupported claim about speed.

## Integrate Seedance 2.0 Fast

The Seedance 2.0 Fast guide documents the selected model, input combinations and task retrieval. Submit once and retain the accepted task ID. If a status request is interrupted, resume checking that task instead of sending a duplicate paid generation.
Seedance 2.0 Fast supports text, first and last frames, and image, video and audio references, with output at 480p, 720p. Generate up to 15 seconds per request. [Model details and Playground](/models/seedance-2-0-fast).

## Connect to Funny AI [#connect-to-wan-api]

Use `https://api.wanapi.app` as the API base URL. Create a key with the **Seedance** model family in [API key settings](/settings/apikeys) and send it as `Authorization: Bearer YOUR_API_KEY`. Keep keys on your server. Playground uses your website session and charges the same account balance; it does not require pasting a key into the browser.

Access requires an enabled account with sufficient balance. `GET /v1/models` lists the models available to your key. Seedance models use `POST /v1/videos`; select the model in the JSON body.

| Setting | Seedance 2.0 Fast |
| --- | --- |
| Model ID | `bytedance/seedance-2.0-fast` |
| `resolution` | `480p`, `720p`; default: `720p`. |
| `duration` | 4–15 output seconds, or `-1` for automatic; default: `5`. |
| `aspectRatio` | `adaptive`, `16:9`, `4:3`, `1:1`, `3:4`, `9:16`, `21:9`; default: `adaptive`. |
| `generateAudio` | `true` by default. `false` does not reduce the token rate. |
| Output | One video per request, at 24 fps. |

The [request fields](#request-fields) describe all 13 top-level fields. Use the field names shown here, including `aspectRatio` and `generateAudio`.

## Submit a Seedance 2.0 Fast task

This is a four-second text-to-video request at 720p. Set `WAN_API_KEY` to your Seedance key on the server. Submit once and save the returned `id`.

```bash
curl https://api.wanapi.app/v1/videos \
  -H "Authorization: Bearer $WAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "bytedance/seedance-2.0-fast",
  "prompt": "A paper boat floats through a sunlit stream. Slow tracking shot.",
  "resolution": "720p",
  "aspectRatio": "16:9",
  "duration": 4,
  "generateAudio": true
}'
```

## Query a Seedance 2.0 Fast task

Save the returned `id` as `TASK_ID`, then query with the same key. Submission returns a task receipt; the video is available after completion. Begin polling every five seconds; see [task statuses and downloads](#poll-and-download-the-video).

```bash
curl "https://api.wanapi.app/v1/videos/$TASK_ID" \
  -H "Authorization: Bearer $WAN_API_KEY"
```

## Seedance 2.0 Fast pricing

Rates are in USD per one million video tokens. Input and output video tokens determine the final cost. Resolution, duration and reference video inputs affect usage; use the matching rate for requests with or without reference video. Audio has no separate price tier.



[View Seedance 2.0 Fast pricing and estimates](/models/seedance-2-0-fast#pricing). Review the estimate in the [Playground](/models/seedance-2-0-fast#playground) before submitting.

## Request fields

Send a JSON object. For a new scene, `model` and a non-empty prompt or at least one media input are required; other fields are optional. Unknown fields are rejected.

| Field | Type | Contract |
| --- | --- | --- |
| `model` | string | Required: `bytedance/seedance-2.0-fast`. |
| `prompt` | string | Text instructions; up to 20,000 characters on this service. A new scene requires a prompt or media input. |
| `image` | URL or URL object | First-frame image URL, or an object with `type: "url"`, `url` and optional `mediaType`. Use `image` or `frameImages`, not both. |
| `frameImages` | array | One `first_frame` and an optional `last_frame`. Each entry has `frameType` and `image`; see the frame example below. |
| `inputReferences` | array | Up to 9 images and 3 videos. Each entry has `type: "url"`, `url` and `mediaType`. The `data`/`mediaType` URL form is also accepted. |
| `aspectRatio` | string | `adaptive` (default), `16:9`, `4:3`, `1:1`, `3:4`, `9:16`, `21:9`. |
| `resolution` | string | `480p`, `720p`. Default: `720p`. Also accepts `854x480`, `1280x720` as resolution tiers; use `aspectRatio` to select the shape. |
| `duration` | integer | 4–15 output seconds, or `-1` for automatic. Default: `5`. |
| `fps` | integer | Fixed at `24`; omit or send `24`. |
| `seed` | integer | Optional; `-1` to `2147483647`. No repeatability guarantee. Do not also specify `providerOptions.bytedance.seed`. |
| `generateAudio` | boolean | Generate audio. Default: `true`; disabling it does not change the token rate. |
| `n` | integer | Fixed at `1`; one video per request. |
| `providerOptions` | object | Optional `bytedance` object: `referenceAudio` (up to 3 HTTP(S) URLs), `seed` (same bounds as top-level `seed`). `draft: true` is not supported. Unknown options are rejected. |

### Input combinations and media limits

- Use `image` for a first frame, or `frameImages` for a first frame and optional last frame. A last frame alone and duplicate frame types are rejected.
- Frames cannot be combined with `inputReferences` or `providerOptions.bytedance.referenceAudio`.
- Reference mode accepts up to 9 images, 3 videos and 3 audio clips, with at most 15 references in total.

- Media inputs must be public HTTP(S) URLs. Upload bytes and credential-bearing URLs are not accepted.
- Images: JPEG, PNG, WebP, BMP, TIFF or GIF; below 30 MB; each side 300–6000 pixels; aspect ratio 0.4–2.5.
- Videos: MP4 or MOV; at most 50 MB per file; each clip 2–15 seconds and at most 15 seconds combined; 300–6000 pixels per side, aspect ratio 0.4–2.5, 24–60 fps.
- Audio: MP3 or WAV; at most 15 MB per file; each clip 2–15 seconds and at most 15 seconds combined. At least one reference image or video is required.
- Remote media size, encoding and duration are checked during processing; URL validation alone cannot guarantee that a file is usable.
- Draft-to-final rendering and arbitrary native task options are not exposed by this endpoint.

## Frame and reference examples

Send these bodies to the same `POST /v1/videos` endpoint. Replace every `example.com` URL with your own directly accessible media URL before submitting. Keep input URLs available until the task finishes.

### First and last frames

For a single first frame, use `image: "https://example.com/first-frame.jpg"` and omit `frameImages`. To set both endpoints of the clip, use:

```json
{
  "model": "bytedance/seedance-2.0-fast",
  "prompt": "The camera slowly moves from the opening scene to the closing scene.",
  "frameImages": [
    {
      "frameType": "first_frame",
      "image": "https://example.com/first-frame.jpg"
    },
    {
      "frameType": "last_frame",
      "image": "https://example.com/last-frame.jpg"
    }
  ],
  "aspectRatio": "adaptive",
  "resolution": "720p",
  "duration": 4
}
```

### Image, video and audio references

Put image and video inputs in `inputReferences`, with an explicit MIME type. Put audio URLs in `providerOptions.bytedance.referenceAudio`. Do not add frame inputs to this request.

```json
{
  "model": "bytedance/seedance-2.0-fast",
  "prompt": "Use the character from the image and the camera movement from the video.",
  "inputReferences": [
    {
      "type": "url",
      "url": "https://example.com/character.jpg",
      "mediaType": "image/jpeg"
    },
    {
      "type": "url",
      "url": "https://example.com/motion.mp4",
      "mediaType": "video/mp4"
    }
  ],
  "providerOptions": {
    "bytedance": {
      "referenceAudio": [
        "https://example.com/sound.wav"
      ]
    }
  },
  "resolution": "720p",
  "duration": 4
}
```

## Poll and download the video

An accepted task returns an object like this. Example IDs and timestamps are illustrative:

```json
{
  "id": "task_EXAMPLE",
  "object": "video",
  "model": "bytedance/seedance-2.0-fast",
  "status": "queued",
  "progress": 0,
  "created_at": 1792022400
}
```

Poll `GET /v1/videos/{task_id}` with your API key. The query returns the same public task ID and model. Use `status` to decide when to stop polling; `progress` is not an estimate of remaining time.

| Status | Meaning | Next step |
| --- | --- | --- |
| `queued` | The task has been accepted. | Continue polling. |
| `in_progress` | Generation is running. | Continue polling. |
| `completed` | The video is ready. | Read `videos[0].url` and download. |
| `failed` | Generation failed. | Stop polling and inspect `error`. |

A completed query includes `videos`, an array of objects containing `url` and `mediaType`. Timestamps use Unix seconds; `completed_at` appears when completion is recorded.

```json
{
  "id": "task_EXAMPLE",
  "object": "video",
  "model": "bytedance/seedance-2.0-fast",
  "status": "completed",
  "progress": 100,
  "created_at": 1792022400,
  "completed_at": 1792022460,
  "videos": [
    {
      "url": "/v1/tasks/task_EXAMPLE/artifacts/video/content",
      "mediaType": "video/mp4"
    }
  ]
}
```

When the returned URL is a relative path, resolve it against `https://api.wanapi.app` and authenticate with your API key. For the example above:

```bash
curl "https://api.wanapi.app/v1/tasks/$TASK_ID/artifacts/video/content" \
  -H "Authorization: Bearer $WAN_API_KEY" \
  -o video.mp4
```

If a signed HTTPS media URL is returned, use it directly without forwarding your API key to that host. Result URLs can expire. Save videos you want to keep to your own storage. Polling and downloading an existing result do not create another generation.

A failed task includes an `error` object with `code` and `message`, for example:

```json
{
  "id": "task_EXAMPLE",
  "object": "video",
  "model": "bytedance/seedance-2.0-fast",
  "status": "failed",
  "error": {
    "code": "generation_failed",
    "message": "Video generation failed"
  }
}
```

## Billing and failure handling

The final charge follows actual video token usage and the current model rate. The Playground estimate is a maximum estimate, not a fixed quote. Longer clips and larger output resolutions can increase token usage. Failed requests are not charged.

- **Invalid parameters:** correct the fields or input combination before submitting again. Check media formats and limits as well as URL syntax.
- **Authentication or model access:** use a valid Seedance key enabled for the requested model.
- **Insufficient balance:** add funds before a new paid request. A key limit does not add account credit.
- **Temporary polling failure:** retry the GET with backoff and a maximum waiting period. A failed query does not mean the generation failed.
- **Submission timeout or missing task ID:** the outcome may be unknown. Do not automatically repeat the POST; it could create a second paid task.
- **Download failure:** retry the existing result before starting a new generation.

Keep the task ID and contact [support](/contact) if an uncertain submission needs investigation.

[Download the Seedance 2.0 Fast OpenAPI schema](https://funnyai.io/models/seedance-2-0-fast/openapi.json).


## Seedance 2.0 Fast limits

- Seedance 2.0 Fast stops at 720p and does not offer Draft mode. Standard 2.0 has larger output tiers; 2.5 offers a longer single-clip duration.
- A last frame requires a first frame in Seedance 2.0 Fast. Frame inputs cannot be combined with the mixed reference collection.
- Seedance 2.0 Fast video and audio references each total at most fifteen seconds. This integration does not expose editing, extension or a separate final-frame image output.

## Seedance 2.0 Fast questions

### Is Seedance 2.0 Fast guaranteed to finish sooner?

No measured completion-time guarantee is provided for Seedance 2.0 Fast here. Treat Fast as the model name and record the elapsed time of your own request separately. A useful comparison also checks whether the complete clip meets the brief, using the same settings and references for each model.

### Can Seedance 2.0 Fast generate 1080p?

No. Seedance 2.0 Fast offers 480p and 720p at 24 fps, with four-to-fifteen-second or automatic duration. Use standard 2.0 when its larger output tiers fit your delivery requirements. The Playground defaults for this variant are a five-second clip at 720p.

### Can reference footage guide Seedance 2.0 Fast?

Yes. Seedance 2.0 Fast accepts up to three reference-video clips totaling at most fifteen seconds. You can combine them with supported image and audio references in reference mode. Describe which file supplies the subject and which supplies the motion, keeping first/last-frame inputs outside this collection.

### Does silent Seedance 2.0 Fast output cost less?

Seedance 2.0 Fast has no separate lower token rate for silent output. Duration, output size and reference-video usage still determine the estimated total. Turn audio off when the creative brief calls for silence or the edit will supply its own sound, then check the live estimate.

### Did Seedance 2.0 Fast generate the shoe video?

No. The shoe illustration was generated with standard Wan 3.0 for five seconds at 480p. It is a scene idea to adapt for Seedance 2.0 Fast, with its actual model identified beside the player. Use a separately generated result when assessing this variant’s motion or completion time.

[Seedance 2.0 Fast vs Mini: plan a matched test](https://funnyai.io/blog/seedance-2-0-fast-vs-mini)

[Official model page](https://docs.byteplus.com/en/docs/ModelArk/2291680)
[Release announcement](https://docs.byteplus.com/en/docs/ModelArk/1159178)