# Seedance 2.0 Mini

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

Turn a written idea or image into short video with Seedance 2.0 Mini. Create clips at 480p or 720p, with optional generated sound. Shape a focused scene in the Playground, review its current estimate and use the API to add that workflow to your application.

Set up a Mini scene below. Sign in to check your balance, service availability and the estimate for the selected request.

## What is Seedance 2.0 Mini?

Seedance 2.0 Mini is a separate ByteDance video model for short scenes from text and media inputs. It supports clips from four to fifteen seconds, or automatic duration, with output at 480p or 720p. Generated sound is optional, so you can prepare a scene with audio or add your soundtrack in a later edit.

A quiet environmental detail is one brief to explore with Seedance 2.0 Mini: a curtain moving in window light, or a jellyfish drifting inside a fixed glass aquarium. Decide what should change and what should remain stable. That distinction gives you a useful way to judge the full clip before revising the prompt.

Seedance 2.0 Mini accepts up to 9 reference images, 3 video clips and 3 audio clips. An audio reference must be accompanied by a reference image or video.

- 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 jellyfish at a desk

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

Prompt: A small translucent lavender jellyfish floats gently inside a round glass aquarium on a wooden desk. Its bell contracts once and delicate tentacles follow through the water. Soft evening window light, an uncluttered cream wall, soothing lilac reflections, medium close shot with a static camera. One continuous five-second shot. No people, no writing, no logos, no watermark.

The aquarium illustration suggests a Seedance 2.0 Mini brief with one moving subject in a stable setting. Watch the jellyfish’s movement and the glass outline across the whole take. This standard Wan 3.0 illustration does not establish the Mini variant’s output quality or cost.

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

## Budget around usable clips

Seedance 2.0 Mini uses its own live video-token rates. Per-second estimates assume 16:9 output at 24 fps; review the chosen duration and input material when budgeting your scene.

Reference video adds input usage and a minimum threshold to Seedance 2.0 Mini. Audio has no separate rate tier, and the model name does not determine the cost of finishing a project. Check the current estimate for your actual request.

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.0316 / billable second without reference video; $0.0190 with reference video. Official comparison: $0.0352 and $0.0211, respectively. Underlying rates: $3.15 / 1M video tokens without reference video; $1.89 with reference video.
- 720p: approximately $0.0680 / billable second without reference video; $0.0408 with reference video. Official comparison: $0.0756 and $0.0454, respectively. Underlying rates: $3.15 / 1M video tokens without reference video; $1.89 with reference video.

## Start with a manageable scene

### Compose the scene in your browser

Use the Seedance 2.0 Mini Playground to choose the starting material and output settings. Check the current estimate and availability before submitting a generation.

### Select Seedance 2.0 Mini in your app

Select the Seedance 2.0 Mini identifier in your app and keep the returned task ID. Changing another model’s resolution does not switch that request to Mini.

## Shape a focused scene

### Start Seedance 2.0 Mini from text

Describe the subject and its surroundings to Seedance 2.0 Mini, then add the movement. A concrete action makes it easier to decide whether the result fits the purpose of the shot.

### Begin with an image

Supply Seedance 2.0 Mini with a first frame when the opening composition matters. An optional last frame can describe the destination, keeping both endpoints within the same frame-based request.

### Use references for different cues

Give Seedance 2.0 Mini separate examples of appearance, movement or sound in reference mode. Explain the role of each source and keep these inputs separate from the first/last-frame mode.

### Plan the sound with the picture

Generate sound with Seedance 2.0 Mini or choose silence for a later edit. Listen to the complete clip and check that the audio fits the timing you want to keep.

## Small scenes for a specific placement

### Seedance 2.0 Mini atmospheric inserts

Explore a modest environmental movement with Seedance 2.0 Mini, such as fabric lifting or light passing over water. Keep the rest of the setting quiet so the finished shot has a clear visual focus.

### Seedance 2.0 Mini moving backgrounds

Use Seedance 2.0 Mini to explore a background with room for text or interface elements you will add later. Review the entire take for changes that could distract from that overlay.

### A visual idea before a larger edit

Try one scene with Seedance 2.0 Mini before expanding it into a sequence. Define what would make the clip useful, so the next request changes a specific part of the result rather than repeating an open-ended prompt.

## Prepare your first small scene

### Pick the visual anchor

Tell Seedance 2.0 Mini which subject or setting must remain recognizable. Use a reference or opening image when that visual direction is already available.

### Add one movement

Give Seedance 2.0 Mini a single action or camera move with a purpose. Keep the first test small enough that the whole result can be judged against the brief.

### Choose the size and review cost

Set the Seedance 2.0 Mini resolution and duration for your placement. Check the estimate after including any reference footage, since input video also affects usage.

### Revise the part that matters

Review Seedance 2.0 Mini for unwanted cuts, shape changes or distracting motion. Save the task and settings, then adjust the instruction that addresses the specific issue you found.

## Connect Seedance 2.0 Mini to your app

The Seedance 2.0 Mini API guide describes its input fields and media rules. Submit once and save the accepted task ID, then retrieve the same task for status and the completed clip. Resume checking that ID after an interrupted status request.
Seedance 2.0 Mini 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-mini).

## 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 Mini |
| --- | --- |
| Model ID | `bytedance/seedance-2.0-mini` |
| `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 Mini 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-mini",
  "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 Mini 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 Mini 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 Mini pricing and estimates](/models/seedance-2-0-mini#pricing). Review the estimate in the [Playground](/models/seedance-2-0-mini#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-mini`. |
| `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-mini",
  "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-mini",
  "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-mini",
  "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-mini",
  "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-mini",
  "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 Mini OpenAPI schema](https://funnyai.io/models/seedance-2-0-mini/openapi.json).


## Seedance 2.0 Mini boundaries

- Seedance 2.0 Mini offers 480p and 720p output. It does not provide Draft mode or the larger output tiers available on standard 2.0.
- Seedance 2.0 Mini reference videos total at most fifteen seconds, with a separate fifteen-second limit for audio. An audio reference needs a visual reference alongside it.
- First/last frames and mixed references are separate modes for Seedance 2.0 Mini. This integration does not expose editing, extension or a separate final-frame image output.

## Seedance 2.0 Mini questions

### Is Seedance 2.0 Mini a setting of the standard model?

No. Seedance 2.0 Mini has its own identifier and rate table. Select it explicitly in the Playground or API request; lowering standard 2.0’s resolution changes that model’s settings rather than selecting Mini.

### Which sizes and lengths does Seedance 2.0 Mini offer?

Seedance 2.0 Mini offers 480p or 720p, with an integer duration from four to fifteen seconds or automatic duration. Output is MP4 at 24 fps. The Playground begins with five seconds at 720p, which you can adjust around the action your scene needs.

### Can Seedance 2.0 Mini combine frames and audio references?

No. Seedance 2.0 Mini frame mode is separate from the mixed reference collection. For reference audio, choose reference mode and include an image or video reference. Use a first frame and optional last frame when you want images to define the shot’s endpoints instead.

### Is Seedance 2.0 Mini always the lowest-cost choice?

The cost of a Seedance 2.0 Mini project depends on duration, output size, reference-video usage and the number of generations you need. Compare current estimates for matching settings, then evaluate the usable results. A model’s name or token rate alone does not determine the final budget.

### Did Seedance 2.0 Mini generate the aquarium clip?

No. The five-second aquarium illustration was generated with standard Wan 3.0 at 480p, as its caption states. You can adapt that scene for Seedance 2.0 Mini, but the displayed clip is not evidence of Mini performance or a comparison with Fast.

[Seedance 2.0 Fast vs Mini: compare the same brief](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)