> ## Documentation Index
> Fetch the complete documentation index at: https://docs.laozhang.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Seedance 2.0 and 2.5 video generation API pricing

> Create Seedance 2.0 and 2.5 video tasks on LaoZhang API, download the MP4, check per-token prices in USD, and reconcile the two call-log rows per task.

Seedance 2.0 and 2.5 generate video from text, images, video, and audio through Volcengine Ark-compatible asynchronous tasks. You need a token in the `SeeDance2` group, and tasks are billed by tokens.

| Item | Details |
| - | - |
| Models | `doubao-seedance-2-5-260628` (2.5), `doubao-seedance-2-0-260128` (2.0 standard), `doubao-seedance-2-0-fast-260128` (fast), `doubao-seedance-2-0-mini-260615` (mini) |
| Base URL | `https://api.laozhang.ai/seedance/api/v3` |
| Create a task | `POST /contents/generations/tasks` |
| Poll a task | `GET /contents/generations/tasks/{id}` until the task succeeds |
| Download the video | `content.video_url`, or `GET https://api.laozhang.ai/v1/videos/{id}/content` |
| Token group | `SeeDance2`; see [Token setup](#token-setup) |
| Billing | By tokens. The group's 0.1714× multiplier converts Volcengine's RMB list prices to USD, about 1.2× the list price at the fixed 1:7 rate. USD prices and per-video estimates are in [Billing and pricing](#billing-and-pricing) |
| Call logs | Each task writes two rows, a pre-charge at creation and a settlement at completion; the task's cost is the sum of both |
| Result lifetime | The signed video URL is usually valid for 24 hours, so save the video as soon as the task succeeds |

<Warning>
  **Use the base URL `https://api.laozhang.ai/seedance/api/v3`.**

  * Don't append the official Ark path `/api/v3/...` directly to `https://api.laozhang.ai`.
  * Don't drop `/api` from the prefix: `/seedance/v3/...` returns the site's HTML instead of API JSON.
</Warning>

## Token setup

| Setting | Value |
| - | - |
| Console | [Token management](https://api.laozhang.ai/token) → create a token |
| Group | `SeeDance2` |
| Billing mode | Usage first (按量优先, recommended) or Usage-based (按量计费) |
| Request header | `Authorization: Bearer $LAOZHANG_API_KEY` |

Seedance models are only available in the `SeeDance2` group, so the token must use that group. Tokens in other groups, such as `default` or `Wan`, can't call them and fail with a no-channel error. A dedicated Seedance token also keeps logs and charges easy to review.

## Endpoints

```text theme={null}
Base URL: https://api.laozhang.ai/seedance/api/v3

Create a task             POST /contents/generations/tasks
Get task status/result    GET  /contents/generations/tasks/{id}

Download the MP4 (compatibility endpoint outside the Seedance base URL):
                          GET  https://api.laozhang.ai/v1/videos/{id}/content
```

Don't call `GET /contents/generations/tasks` without a task ID. On this relay the list endpoint returns the site's HTML instead of JSON, so create tasks and then query each one by its ID.

## Billing and pricing

Seedance is billed by tokens, at Volcengine Ark's list price plus 20%. The markup covers taxes, currency conversion and cross-border settlement, platform operations, and technical support. Since October 14, 2026, prices convert like this:

* USD price = Volcengine's RMB list price × 0.1714 (the `SeeDance2` group multiplier)
* At the fixed exchange rate of 1:7, 0.1714 × 7 ≈ 1.2, so you pay about 1.2× the list price

Amounts in call logs already include the multiplier, so don't apply it again. The price depends on the model, the output resolution, and whether the request includes an input video. Prices per 1M tokens:

| Model ID | Output | List price (no input video / with input video) | LaoZhang API (no input video / with input video) |
| - | - | -: | -: |
| `doubao-seedance-2-5-260628` | 480p, 720p | ¥70 / ¥42 | \$12.00 / \$7.20 |
| `doubao-seedance-2-5-260628` | 1080p | ¥77 / ¥46 | \$13.20 / \$7.88 |
| `doubao-seedance-2-0-260128` | 480p, 720p | ¥46 / ¥28 | \$7.88 / \$4.80 |
| `doubao-seedance-2-0-260128` | 1080p | ¥51 / ¥31 | \$8.74 / \$5.31 |
| `doubao-seedance-2-0-fast-260128` | 480p, 720p | ¥37 / ¥22 | \$6.34 / \$3.77 |
| `doubao-seedance-2-0-mini-260615` | 480p, 720p | ¥23 / ¥14 | \$3.94 / \$2.40 |

List prices are from [Volcengine Ark model pricing](https://www.volcengine.com/docs/82379/1544106?lang=zh) (in Chinese). The fast and mini models go up to 720p.

Approximate cost of one 16:9 video with 5 seconds of output and no input video, counting the 121 frames actually output (about 108,900 tokens at 720p and 245,025 tokens at 1080p):

* Seedance 2.5: about \$1.31 at 720p and \$3.23 at 1080p
* Seedance 2.0: about \$0.86 at 720p and \$2.14 at 1080p
* fast: about \$0.69 at 720p
* mini: about \$0.43 at 720p

The actual token count is the task's `usage.completion_tokens`, and the task's cost is the sum of its two rows in call logs. Model prices are also on the [console pricing page](https://api.laozhang.ai/account/pricing), and the [model and pricing catalog](/en/models) lists groups and multipliers.

Task details may show the multiplier as `topup_convert_ratio: 0.1714` next to `group_ratio: 1`. The two fields serve different purposes: `group_ratio: 1` doesn't mean the multiplier was skipped.

### Estimate the cost of a task

Volcengine publishes this formula for estimating the cost:

```text theme={null}
Cost = token unit price × token usage
Token usage ≈ (input video duration + output video duration) × output width × output height × frame rate / 1024
```

The unit price depends on the output resolution and on whether the request includes an input video, and the output length drives usage:

* 1080p output costs more per token than 480p and 720p; see the table above.
* A request with an input video (`video_url`) has a lower unit price, shown in the "with input video" figures above. The input video's duration also counts toward usage, though, so the same 5 seconds of output usually costs more overall.
* Volcengine also sets a minimum token usage for requests with an input video and bills the minimum when the estimate falls below it.
* Longer output uses more tokens. Seedance 2.5 defaults `duration` to `-1`, which lets the model choose a length from 4 to 30 seconds, so set `duration` explicitly when cost matters.

Volcengine lists these RMB prices for a 16:9 video with 5 seconds of output ([Volcengine Ark model pricing](https://www.volcengine.com/docs/82379/1544106?lang=zh), in Chinese). Use them to compare resolutions and inputs; for LaoZhang API prices in USD, use the rates above.

| Model | Input | 480p | 720p | 1080p |
| - | - | - | - | - |
| `doubao-seedance-2-5-260628` | No input video | ¥3.36 | ¥7.56 | ¥18.71 |
| `doubao-seedance-2-5-260628` | 2–30 s of input video | ¥3.63–14.12 | ¥8.16–31.75 | ¥20.12–78.25 |
| `doubao-seedance-2-0-260128` | No input video | ¥2.31 | ¥4.97 | ¥12.39 |
| `doubao-seedance-2-0-260128` | 2–15 s of input video | ¥2.53–5.62 | ¥5.44–12.10 | ¥13.56–30.13 |
| `doubao-seedance-2-0-fast-260128` | No input video | ¥1.86 | ¥4.00 | Not supported |
| `doubao-seedance-2-0-fast-260128` | 2–15 s of input video | ¥1.99–4.42 | ¥4.28–9.50 | Not supported |
| `doubao-seedance-2-0-mini-260615` | No input video | ¥1.16 | ¥2.48 | Not supported |
| `doubao-seedance-2-0-mini-260615` | 2–15 s of input video | ¥1.27–2.81 | ¥2.72–6.05 | Not supported |

Each range runs from a 2–4 second input video to the longest one allowed: 30 seconds for Seedance 2.5 and 15 seconds for the 2.0 models.

### Why one task has two rows in call logs

The final token usage isn't known when you create a task. LaoZhang API records an estimated pre-charge first, then settles the difference from the final `usage.completion_tokens`. Both rows belong to one task: they aren't two requests or two full charges.

| Row | When it appears | What it shows |
| - | - | - |
| Pre-charge | When the task is created | Marked non-streaming; shows the token, the `SeeDance2` group, the group multiplier, and the source IP |
| Settlement | When the task finishes | Marked streaming; shows the completion tokens and the extra charge or refund |

**Task cost = pre-charge amount + settlement amount.** For example, a pre-charge of about \$0.90 followed by a settlement of about \$3.58 adds up to one task that costs about \$4.48. If actual usage is lower than the estimate, the settlement row refunds the difference instead.

The streaming label on the settlement row comes from the settlement process. It doesn't mean your client used a streaming API, and it isn't a request from another key. The settlement row usually doesn't repeat the token, group, or IP, so use the pre-charge row to identify where a request came from.

To reconcile one task:

1. Search [call logs](https://api.laozhang.ai/log) for `doubao-seedance` or the full model ID you used.
2. Use the pre-charge row to confirm the token, group, and source IP.
3. Use the settlement row to read the final completion tokens.
4. Match the task ID and its creation and completion times on the asynchronous task page, and count the two rows as one video.

If a task fails or expires, check its rows in call logs. If it still shows a charge you don't expect, contact [support](mailto:hi@laozhang.ai) with the task ID.

## How a task works

<Steps>
  <Step title="Create a task">
    Call `POST /contents/generations/tasks` with the plain model ID in `model` and the prompt and any media in the `content` array. Save the returned `id`.
  </Step>

  <Step title="Poll the task">
    Call `GET /contents/generations/tasks/{id}` until `status` reaches a final state.
  </Step>

  <Step title="Download the video">
    After the task succeeds, download the video from `content.video_url`, or call `/v1/videos/{id}/content`.

    If you set `return_last_frame` to `true`, also read `content.last_frame_url`.
  </Step>
</Steps>

## Task statuses

| Status | Meaning | What to do |
| - | - | - |
| `queued` | The task is waiting to start | Keep polling |
| `running` | The video is being generated | Keep polling |
| `succeeded` | The task finished; the result is in `content` | Download the video |
| `completed` | The task finished (LaoZhang-compatible task object); same as `succeeded` | Download the video |
| `failed` | The task failed; details are in `error` | Stop polling and fix the request |
| `expired` | The task expired | Stop polling and create a new task |

Use one rule for every response:

* Keep polling while `status` is `queued` or `running`.
* Treat `succeeded` and `completed` as success.
* Treat any other value as final. On a final failure, stop polling and log the full response.

The query endpoint returns an Ark-style task object with `status` and `content.video_url`. If the response has a different shape:

* A LaoZhang-compatible task object can instead put the URL in top-level `result_url` or in `data.content.video_url`.
* If you can't find a URL, download through `/v1/videos/{id}/content`.

## Models

| Model ID | Version | Use it for |
| - | - | - |
| `doubao-seedance-2-0-260128` | Seedance 2.0 standard | Standard quality, first and last frames, video editing, and more stable output |
| `doubao-seedance-2-0-fast-260128` | Seedance 2.0 fast | Faster generation; text to video; image, video, and audio references; video extension; track completion. No 1080p. |
| `doubao-seedance-2-0-mini-260615` | Seedance 2.0 mini | Lowest cost, with nearly the same features as standard; up to 720p and 4–15 seconds |
| `doubao-seedance-2-5-260628` | Seedance 2.5 | 4–30 seconds; up to 30 reference images, 10 videos, and 10 audio clips, and audio can be the only reference; up to 1080p; MP4 or MOV output |

Model IDs are from LaoZhang API's public pricing as of September 24, 2026, and the mini and 2.5 capabilities come from the model comparison in Volcengine's [Seedance 2.5 guide](https://docs.volcengine.com/docs/ark/seedance-2-5?lang=zh) (in Chinese). Seedance 2.5 adds `ratio` and `duration` constraints for first-frame, first-and-last-frame, video-editing, and video-extension tasks, so read that guide before you switch a task to 2.5.

Send the plain model ID in `model`. Don't send a console endpoint ID (`ep-...`) and don't append labels such as `(2.0-audio-video)` to the name: the relay matches channels by plain model ID.

## Set up your environment

```bash theme={null}
export LAOZHANG_API_KEY="YOUR_API_KEY"   # replace with your LaoZhang API key
```

Before you run the examples:

* The shell examples use `curl` and `jq`. Install jq with `brew install jq` or `sudo apt-get install jq`.
* The Python example needs `pip install requests`.
* Each create example saves its response to `create.json`, which the [query step](#query-a-task) reads.

## Text to video

Every create request goes to `POST /seedance/api/v3/contents/generations/tasks`; the headers, request parameters, and `content` items are described after the examples, in [Create a task](#create-a-task).

```bash theme={null}
curl -sS -X POST "https://api.laozhang.ai/seedance/api/v3/contents/generations/tasks" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  --data-raw '{
    "model": "doubao-seedance-2-0-fast-260128",
    "content": [
      {
        "type": "text",
        "text": "First-person apple fruit tea ad, 4 seconds, fast-paced edit, show apple tea preparation and finished product, fresh bright style"
      }
    ],
    "ratio": "16:9",
    "duration": 4,
    "resolution": "720p",
    "watermark": false,
    "generate_audio": false,
    "return_last_frame": true
  }' | tee create.json
```

The create response usually contains only the task ID:

```json theme={null}
{
  "id": "cgt-example-task-id"
}
```

## First and last frames

```bash theme={null}
curl -sS -X POST "https://api.laozhang.ai/seedance/api/v3/contents/generations/tasks" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  --data-raw '{
    "model": "doubao-seedance-2-0-260128",
    "content": [
      {
        "type": "text",
        "text": "The first frame is image 1 and the final frame is image 2. Create a smooth commercial transition from a red apple product close-up to a finished apple fruit tea cup. Keep product appearance consistent and avoid people."
      },
      {
        "type": "image_url",
        "image_url": {
          "url": "https://ark-project.tos-cn-beijing.volces.com/doc_image/r2v_tea_pic1.jpg"
        },
        "role": "first_frame"
      },
      {
        "type": "image_url",
        "image_url": {
          "url": "https://ark-project.tos-cn-beijing.volces.com/doc_image/r2v_tea_pic2.jpg"
        },
        "role": "last_frame"
      }
    ],
    "ratio": "adaptive",
    "duration": 4,
    "resolution": "720p",
    "watermark": false,
    "generate_audio": false,
    "return_last_frame": true
  }' | tee create.json
```

## Image, video, and audio references

```bash theme={null}
curl -sS -X POST "https://api.laozhang.ai/seedance/api/v3/contents/generations/tasks" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  --data-raw '{
    "model": "doubao-seedance-2-0-fast-260128",
    "content": [
      {
        "type": "text",
        "text": "Use image 1 for the apple product details, video 1 for first-person camera motion, and audio 1 as the background music. Generate a concise apple fruit tea commercial with quick ingredient cuts and a clean finished cup close-up."
      },
      {
        "type": "image_url",
        "image_url": {
          "url": "https://ark-project.tos-cn-beijing.volces.com/doc_image/r2v_tea_pic1.jpg"
        },
        "role": "reference_image"
      },
      {
        "type": "video_url",
        "video_url": {
          "url": "https://ark-project.tos-cn-beijing.volces.com/doc_video/r2v_tea_video1.mp4"
        },
        "role": "reference_video"
      },
      {
        "type": "audio_url",
        "audio_url": {
          "url": "https://ark-project.tos-cn-beijing.volces.com/doc_audio/r2v_tea_audio1.mp3"
        },
        "role": "reference_audio"
      }
    ],
    "ratio": "16:9",
    "duration": 4,
    "resolution": "720p",
    "watermark": false,
    "generate_audio": true
  }' | tee create.json
```

To keep a real person's identity or likeness consistent, an ordinary face image isn't enough. Complete the [real-person and virtual human asset flow](/en/api-capabilities/seedance2-human-virtual-workflow) first, and once the asset is `Active`, send its `asset://...` URI as a `reference_image`.

## Query a task

```http theme={null}
GET https://api.laozhang.ai/seedance/api/v3/contents/generations/tasks/{id}
```

Read the task ID from `create.json` and check the task:

```bash theme={null}
TASK_ID=$(jq -r '.id' create.json)

curl -sS "https://api.laozhang.ai/seedance/api/v3/contents/generations/tasks/$TASK_ID" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -H "Accept: application/json" | tee task.json | jq -r '.status'
```

Repeat the query every 10–15 seconds while `status` is `queued` or `running`. A successful response looks like this:

```json theme={null}
{
  "id": "cgt-example-task-id",
  "model": "doubao-seedance-2-0-fast-260128",
  "status": "succeeded",
  "ratio": "16:9",
  "duration": 4,
  "resolution": "720p",
  "content": {
    "video_url": "https://example.com/generated-video.mp4",
    "last_frame_url": "https://example.com/last-frame.jpeg"
  },
  "usage": {
    "completion_tokens": 87300,
    "total_tokens": 87300
  }
}
```

Result URLs are temporary signed URLs, usually valid for 24 hours. In production, download each result as soon as the task succeeds and copy it to your own storage.

## Download the result

```http theme={null}
GET https://api.laozhang.ai/v1/videos/{id}/content
```

If the task detail includes a video URL, download it directly. It's a signed URL, so no `Authorization` header is needed:

```bash theme={null}
VIDEO_URL=$(jq -r '.content.video_url // .result_url // .data.content.video_url // empty' task.json)
curl -L -o seedance-output.mp4 "$VIDEO_URL"
```

If there's no URL you can parse, or you only need the file, use the compatibility endpoint. It lives under `https://api.laozhang.ai/v1`, not `/seedance/api/v3`. After the task succeeds, it looks up the stored result on the server and returns the MP4 or redirects to it:

```bash theme={null}
curl -L "https://api.laozhang.ai/v1/videos/$TASK_ID/content" \
  -H "Authorization: Bearer $LAOZHANG_API_KEY" \
  -o seedance-output.mp4
```

## Python example

This example creates a text-to-video task, polls for up to 20 minutes, and saves the MP4. Install the dependency with `pip install requests`.

```python theme={null}
import os
import time

import requests

API_KEY = os.environ["LAOZHANG_API_KEY"]
BASE_URL = "https://api.laozhang.ai/seedance/api/v3"
DOWNLOAD_URL = "https://api.laozhang.ai/v1/videos/{task_id}/content"
PENDING = {"queued", "running"}
SUCCESS = {"succeeded", "completed"}
POLL_INTERVAL = 15   # seconds between status checks
TIMEOUT = 20 * 60    # stop waiting after 20 minutes; raise it for long videos

HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
    "Accept-Encoding": "identity",
}


def task_status(task):
    status = task.get("status")
    if status is None and isinstance(task.get("data"), dict):
        status = task["data"].get("status")
    return str(status or "").lower()


def find_video_url(task):
    data = task.get("data") if isinstance(task.get("data"), dict) else {}
    for content in (task.get("content"), data.get("content")):
        if isinstance(content, dict) and content.get("video_url"):
            return content["video_url"]
    return task.get("result_url")


payload = {
    "model": "doubao-seedance-2-0-fast-260128",
    "content": [
        {
            "type": "text",
            "text": "First-person apple fruit tea ad, 4 seconds, fast-paced edit, fresh bright style",
        }
    ],
    "ratio": "16:9",
    "duration": 4,
    "resolution": "720p",
    "watermark": False,
    "generate_audio": False,
    "return_last_frame": True,
}

create_resp = requests.post(
    f"{BASE_URL}/contents/generations/tasks",
    headers=HEADERS,
    json=payload,
    timeout=60,
)
create_resp.raise_for_status()
task_id = create_resp.json()["id"]
print("Task ID:", task_id)

deadline = time.monotonic() + TIMEOUT
while True:
    query_resp = requests.get(
        f"{BASE_URL}/contents/generations/tasks/{task_id}",
        headers=HEADERS,
        timeout=60,
    )
    query_resp.raise_for_status()
    task = query_resp.json()
    status = task_status(task)
    print("Status:", status)

    if status in SUCCESS:
        break
    if status not in PENDING:
        raise RuntimeError(f"Task {task_id} ended with status {status!r}: {task}")
    if time.monotonic() > deadline:
        raise TimeoutError(f"Task {task_id} did not finish within {TIMEOUT // 60} minutes")
    time.sleep(POLL_INTERVAL)

video_url = find_video_url(task)
if video_url:
    # Signed URL: download it without the Authorization header.
    video_resp = requests.get(video_url, timeout=300)
else:
    video_resp = requests.get(
        DOWNLOAD_URL.format(task_id=task_id),
        headers={"Authorization": f"Bearer {API_KEY}", "Accept": "video/mp4,*/*"},
        timeout=300,
    )
video_resp.raise_for_status()
with open(f"{task_id}.mp4", "wb") as output:
    output.write(video_resp.content)
print(f"Saved {task_id}.mp4")
```

## Create a task

```http theme={null}
POST https://api.laozhang.ai/seedance/api/v3/contents/generations/tasks
```

### Headers

| Header | Required | Value |
| - | - | - |
| `Authorization` | Yes | `Bearer $LAOZHANG_API_KEY`, using a token in the `SeeDance2` group |
| `Content-Type` | Yes | `application/json` |
| `Accept` | Recommended | `application/json` |
| `Accept-Encoding` | Optional, for debugging | `identity`, which avoids compressed responses that some clients decode poorly |

### Request parameters

| Parameter | Type | Required | Description |
| - | - | - | - |
| `model` | string | Yes | Plain model ID, for example `doubao-seedance-2-0-fast-260128` |
| `content` | array | Yes | Multimodal content array; the text prompt goes here too |
| `ratio` | string | No | `16:9`, `4:3`, `1:1`, `3:4`, `9:16`, `21:9`, or `adaptive` |
| `duration` | integer | No | 4–15 seconds for the 2.0 models, 4–30 for Seedance 2.5, or `-1` to let the model choose (the 2.5 default) |
| `frames` | integer | No | Output length in frames; Seedance 1.0 only. Use `duration` with Seedance 2.0 and 2.5 |
| `resolution` | string | No | `480p`, `720p`, or `1080p`; fast and mini go up to `720p`. None of the four models supports `4k`; sending it returns a 400 at once and isn't charged |
| `watermark` | boolean | No | Whether to add a watermark |
| `generate_audio` | boolean | No | Whether the video includes sound; defaults to `true` |
| `return_last_frame` | boolean | No | Whether to return a URL for the last frame |

### `content` items

| Field | Type | Required | Description |
| - | - | - | - |
| `type` | string | Yes | `text`, `image_url`, `video_url`, or `audio_url` |
| `text` | string | When `type` is `text` | Prompt text |
| `image_url.url` | string | When `type` is `image_url` | Image URL |
| `video_url.url` | string | When `type` is `video_url` | Video URL |
| `audio_url.url` | string | When `type` is `audio_url` | Audio URL |
| `role` | string | Recommended for media | What the asset is for |

Common `role` values:

| `role` | Purpose |
| - | - |
| `first_frame` | First-frame image |
| `last_frame` | Last-frame image |
| `reference_image` | Image reference |
| `reference_video` | Video reference |
| `reference_audio` | Audio reference |

With the Seedance 2.0 models (standard, fast, and mini), audio can't be the only reference: when you send `audio_url`, include at least one image or video in the same request. Seedance 2.5 accepts audio as the only reference.

## Frequently asked questions

### Was I charged twice for one Seedance task?

No. The two rows are the pre-charge and the settlement for one task, and their sum is the task's cost; see [why one task has two rows in call logs](#why-one-task-has-two-rows-in-call-logs) to reconcile them.

### How much does a 5-second video cost?

At the prices current on October 14, 2026, for a 16:9 task with no input video and a 5-second output (121 frames):

* Seedance 2.5: about \$1.31 at 720p, \$3.23 at 1080p
* Seedance 2.0 standard: about \$0.86 at 720p, \$2.14 at 1080p
* fast: about \$0.69 at 720p; mini: about \$0.43 at 720p

Cost scales with duration, so 10 seconds is roughly double. The actual token count is `usage.completion_tokens` in the task result; see [Estimate the cost of a task](#estimate-the-cost-of-a-task).

### How much more does Seedance 2.5 cost than 2.0?

About 1.5× per token at the same resolution: \$12.00 versus \$7.88 per 1M tokens at 720p, and \$13.20 versus \$8.74 at 1080p, without input video. The same 5-second 720p video costs about \$1.31 on 2.5 and \$0.86 on 2.0. What 2.5 adds (clips over 15 seconds, more reference assets, audio-only references, MOV output) is in [Which model should I use](#which-model-should-i-use-20-standard-fast-mini-or-25).

### Am I charged when a request is rejected or a task fails?

No. A create request that is rejected outright, for example with a 4xx parameter error and no task ID, isn't charged. If the task was created but ends as `failed` or `expired`, the pre-charge is refunded when the task settles.

The actual charge is in [call logs](https://api.laozhang.ai/log). If a failed or expired task still shows a charge, contact [support](mailto:hi@laozhang.ai) with the task ID.

### Is the `SeeDance2` group multiplier a discount?

No. The 0.1714 multiplier converts Volcengine's RMB list prices to your USD balance at about 1.2× the list price; the markup covers taxes, currency conversion and cross-border settlement, platform operations, and technical support. See [billing and pricing](#billing-and-pricing) for the conversion and per-token prices.

### Why does 1080p cost more, and does portrait cost more?

1080p costs more for two reasons, and aspect ratio barely matters. Its per-token price is higher (see [billing and pricing](#billing-and-pricing)), and token usage grows with the number of output pixels. Five seconds at 720p use about 108,900 tokens, and five seconds at 1080p use about 245,025, so a 1080p video costs much more.

At a given resolution every ratio has about the same pixel count: at 720p, 16:9 is 1280×720 and 9:16 is 720×1280. Landscape, portrait, and square videos therefore cost about the same. The formula is in [Estimate the cost of a task](#estimate-the-cost-of-a-task).

### What path and `model` value should I send?

Send requests to `/seedance/api/v3/contents/generations/tasks`. Removing `/api` from the prefix (`/seedance/v3/...`) returns the site's HTML instead of JSON, and so does the list endpoint without a task ID.

In `model`, send the plain model ID, such as `doubao-seedance-2-0-260128`. Don't pass an `ep-...` endpoint ID, and don't add a label after the ID.

### Which model should I use: 2.0 standard, fast, mini, or 2.5?

Pick by the capability you need:

* **1080p:** 2.0 standard or 2.5. Fast and mini stop at 720p.
* **More than 15 seconds, more than 9 reference images, audio as the only reference, or MOV output:** 2.5. The 2.0 models accept up to 9 images, 3 videos, and 3 audio clips.
* **Lowest cost:** mini has the lowest price, and fast sits between mini and standard. Within the 2.0 family, standard gives the highest quality.

All four models use the same endpoint and the `SeeDance2` group. Compare prices in [Billing and pricing](#billing-and-pricing) and capabilities in [Models](#models).

### Why does my video have sound, and how do I turn it off?

Seedance 2.0 and 2.5 default `generate_audio` to `true`, so the model adds voices, sound effects, and background music that match the prompt and picture, in mono.

Send `"generate_audio": false` for a silent video. For spoken lines, putting the dialogue in double quotes helps.

### Where is the final video URL, and how long does it last?

In the Ark-style task detail, it's `content.video_url`, valid for 24 hours. A LaoZhang-compatible task object may return it as top-level `result_url` or as `data.content.video_url`. If you only need the file, call `/v1/videos/{id}/content`.

Volcengine keeps the video URL valid for 24 hours, and a URL for a Seedance 2.5 video can be downloaded at most 100 times. Download the video as soon as the task succeeds, store it yourself, and give your users your own URL.

### Can audio be the only reference?

Only with Seedance 2.5. With the Seedance 2.0 models (standard, fast, and mini), send the audio together with at least one image or video.

## Related documentation

* [Seedance real-person and virtual assets API](/en/api-capabilities/seedance2-human-virtual-workflow)
* [Wan 2.7 video generation API](/en/api-capabilities/wan-video-generation)
* [Sora 2 API retired: move to Wan or Seedance](/en/api-capabilities/sora2/official-forward)
* [Model and pricing catalog](/en/models)
* [How to review call logs](/en/faq/call-logs)
* [Volcengine Ark model pricing](https://www.volcengine.com/docs/82379/1544106?lang=zh) (in Chinese)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.