bytedance/seedance-2.5/draft-complete

video-to-video

Seedance 2.5 Draft Complete API by ByteDance

bytedance/seedance-2.5/draft-complete

Draft-complete

Render the 1080p final of a completed Seedance 2.5 draft. Prompt, inputs, duration, ratio, seed and audio come from the draft; only draft_id, return_last_frame, output_format and watermark are accepted.

Seedance 2.5 Draft Complete is developed by ByteDance. Atlas Cloud (operated by Atlas Cloud AI LLC) provides access to it and does not own it. All trademarks belong to their respective owners.

INPUT

Draft ID *

Resolution

Additional Settings

OUTPUT

Idle

Your generated videos will appear here

Configure your settings and click Run to get started

Review the price on the completion page. Each completion is billed separately.

Here's what you can do next:

Seedance 2.0 Kling v3 Vidu Wan2.7

Parameters

Code Example
import requests
import time

# Step 1: Start video generation
generate_url = "https://api.atlascloud.ai/api/v1/model/generateVideo"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "bytedance/seedance-2.5/draft-complete",  # Required. Model name
    "draft_id": "example_value",  # Required. The id of a completed Seedance 2
    "output_format": "mp4",  # Output video container format. options: mp4 | mov
    "watermark": False,  # Whether to add a watermark
    "return_last_frame": False,  # Whether to return the last frame as a separate image
}

generate_response = requests.post(generate_url, headers=headers, json=data)
generate_result = generate_response.json()
prediction_id = generate_result["data"]["id"]

# Step 2: Poll for result
poll_url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"

def check_status():
    while True:
        response = requests.get(poll_url, headers={"Authorization": "Bearer $ATLASCLOUD_API_KEY"})
        result = response.json()

        if result["data"]["status"] in ["completed", "succeeded"]:
            print("Generated video:", result["data"]["outputs"][0])
            return result["data"]["outputs"][0]
        elif result["data"]["status"] == "failed":
            raise Exception(result["data"]["error"] or "Generation failed")
        else:
            # Still processing, wait 2 seconds
            time.sleep(2)

video_url = check_status()

Install

Install the required package for your language.

pip install requests

Authentication

All API requests require authentication via an API key. You can get your API key from the Atlas Cloud dashboard.

export ATLASCLOUD_API_KEY="your-api-key-here"

HTTP Headers

import os

API_KEY = os.environ.get("ATLASCLOUD_API_KEY")
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

Keep your API key secure

Never expose your API key in client-side code or public repositories. Use environment variables or a backend proxy instead.

Submit a request

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateVideo"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "your-model",
    "prompt": "A beautiful landscape"
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

Submit a Request

Submit an asynchronous generation request. The API returns a prediction ID that you can use to check the status and retrieve the result.

POST/api/v1/model/generateVideo

Request Body

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateVideo"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}

data = {
    "model": "bytedance/seedance-2.5/draft-complete",
    "prompt": "A beautiful sunset over the ocean with gentle waves"
}

response = requests.post(url, headers=headers, json=data)
result = response.json()

print(f"Prediction ID: {result['data']['id']}")
print(f"Status: {result['data']['status']}")

Response

{
  "code": 200,
  "data": {
    "id": "pred_abc123",
    "status": "processing",
    "model": "model-name",
    "created_at": "2025-01-01T00:00:00Z"
  }
}

Check Status

Poll the prediction endpoint to check the current status of your request.

GET/api/v1/model/prediction/{prediction_id}

Polling Example

import requests
import time

prediction_id = "pred_abc123"
url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

while True:
    response = requests.get(url, headers=headers)
    result = response.json()
    status = result["data"]["status"]
    print(f"Status: {status}")

    if status in ["completed", "succeeded"]:
        output_url = result["data"]["outputs"][0]
        print(f"Output URL: {output_url}")
        break
    elif status == "failed":
        print(f"Error: {result['data'].get('error', 'Unknown')}")
        break

    time.sleep(3)

Status Values

processingThe request is still being processed.

completedGeneration is complete. Outputs are available.

succeededGeneration succeeded. Outputs are available.

failedGeneration failed. Check the error field.

Completed Response

{
  "data": {
    "id": "pred_abc123",
    "status": "completed",
    "outputs": [
      "https://storage.atlascloud.ai/outputs/result.mp4"
    ],
    "metrics": {
      "predict_time": 45.2
    },
    "created_at": "2025-01-01T00:00:00Z",
    "completed_at": "2025-01-01T00:00:10Z"
  }
}

Upload Files

Upload files to Atlas Cloud storage and get a URL you can use in your API requests. Use multipart/form-data to upload.

POST/api/v1/model/uploadMedia

Upload Example

import requests

url = "https://api.atlascloud.ai/api/v1/model/uploadMedia"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

with open("image.png", "rb") as f:
    files = {"file": ("image.png", f, "image/png")}
    response = requests.post(url, headers=headers, files=files)

result = response.json()
download_url = result["data"]["download_url"]
print(f"File URL: {download_url}")

Response

{
  "data": {
    "download_url": "https://storage.atlascloud.ai/uploads/abc123/image.png",
    "file_name": "image.png",
    "content_type": "image/png",
    "size": 1024000
  }
}

Input Schema

The following parameters are accepted in the request body.

Total: 5Required: 2Optional: 3

modelstringrequired

Model name.

Default: "bytedance/seedance-2.5/draft-complete"

draft_idstringrequired

The id of a completed Seedance 2.5 draft (the draft's prediction id, returned as draft_id when the draft was generated with draft=true on bytedance/seedance-2.5/text-to-video, image-to-video or reference-to-video). The final is rendered at 1080p from the draft's own prompt, inputs, duration, aspect ratio, seed and audio settings; do not send those fields again. A draft can be completed any number of times within 7 days of its creation; each completion is a separate task.

output_formatstring

Output video container format. 'mp4' is the default; 'mov' encodes yuv444p for higher color fidelity, suited to multi-round editing/extension pipelines where recompression loss accumulates.

Default: "mp4"

mp4mov

watermarkboolean

Whether to add a watermark.

Default: false

return_last_frameboolean

Whether to return the last frame as a separate image.

Default: false

Example Request Body

{
  "model": "bytedance/seedance-2.5/draft-complete",
  "draft_id": "example_draft_id",
  "output_format": "mp4",
  "watermark": false,
  "return_last_frame": false
}

Output Schema

The API returns a prediction response with the generated output URLs.

codeinteger

messagestring

dataunknown

Example Response

{
  "id": "pred_abc123",
  "status": "completed",
  "model": "model-name",
  "outputs": [
    "https://storage.atlascloud.ai/outputs/result.mp4"
  ],
  "metrics": {
    "predict_time": 45.2
  },
  "created_at": "2025-01-01T00:00:00Z",
  "completed_at": "2025-01-01T00:00:10Z"
}

Atlas Cloud Skills

Atlas Cloud Skills integrates 400+ AI models directly into your AI coding assistant. One command to install, then use natural language to generate images, videos, and chat with LLMs.

Supported Clients

Claude Code

OpenAI Codex

Gemini CLI

Cursor

Windsurf

VS Code

Trae

GitHub Copilot

Cline

Roo Code

Amp

Goose

Replit

40+ supported clients

Install

npx skills add AtlasCloudAI/atlas-cloud-skills

Setup API Key

Get your API key from the Atlas Cloud dashboard and set it as an environment variable.

export ATLASCLOUD_API_KEY="your-api-key-here"

Capabilities

Once installed, you can use natural language in your AI assistant to access all Atlas Cloud models.

Image GenerationGenerate images with models like Nano Banana 2, Z-Image, and more.

Video CreationCreate videos from text or images with Kling, Vidu, Veo, etc.

LLM ChatChat with Qwen, DeepSeek, and other large language models.

Media UploadUpload local files for image editing and image-to-video workflows.

Learn more

github.com/AtlasCloudAI/atlas-cloud-skills

MCP Server

Atlas Cloud MCP Server connects your IDE with 400+ AI models via the Model Context Protocol. Works with any MCP-compatible client.

Supported Clients

Cursor

VS Code

Windsurf

Claude Code

OpenAI Codex

Gemini CLI

Cline

Roo Code

100+ supported clients

Install

npx -y atlascloud-mcp

Configuration

Add the following configuration to your IDE's MCP settings file.

{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": [
        "-y",
        "atlascloud-mcp"
      ],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}

Available Tools

atlas_generate_imageGenerate images from text prompts.

atlas_generate_videoCreate videos from text or images.

atlas_chatChat with large language models.

atlas_list_modelsBrowse 400+ available AI models.

atlas_quick_generateOne-step content creation with auto model selection.

atlas_upload_mediaUpload local files for API workflows.

Learn more

github.com/AtlasCloudAI/mcp-server

API Schema

{
  "info": {
    "title": "AtlasCloud API",
    "version": "1.0.0",
    "description": "Seedance 2.5 draft completion: render the 1080p final of a completed draft."
  },
  "paths": {
    "/api/v1/model/prediction/{request_id}": {
      "get": {
        "parameters": [
          {
            "in": "path",
            "name": "request_id",
            "required": true,
            "schema": {
              "description": "Request ID",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "Result of the request."
          }
        }
      },
      "x-api-name": "model_result"
    },
    "/api/v1/model/generateVideo": {
      "post": {
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Input"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "The request status."
          }
        }
      },
      "x-api-name": "model_run"
    }
  },
  "openapi": "3.0.0",
  "servers": [
    {
      "url": "https://api.atlascloud.ai"
    }
  ],
  "components": {
    "schemas": {
      "Input": {
        "type": "object",
        "required": [
          "model",
          "draft_id"
        ],
        "properties": {
          "model": {
            "type": "string",
            "description": "Model name.",
            "default": "bytedance/seedance-2.5/draft-complete"
          },
          "draft_id": {
            "type": "string",
            "description": "The id of a completed Seedance 2.5 draft (the draft's prediction id, returned as draft_id when the draft was generated with draft=true on bytedance/seedance-2.5/text-to-video, image-to-video or reference-to-video). The final is rendered at 1080p from the draft's own prompt, inputs, duration, aspect ratio, seed and audio settings; do not send those fields again. A draft can be completed any number of times within 7 days of its creation; each completion is a separate task."
          },
          "output_format": {
            "type": "string",
            "default": "mp4",
            "enum": [
              "mp4",
              "mov"
            ],
            "description": "Output video container format. 'mp4' is the default; 'mov' encodes yuv444p for higher color fidelity, suited to multi-round editing/extension pipelines where recompression loss accumulates."
          },
          "watermark": {
            "type": "boolean",
            "default": false,
            "description": "Whether to add a watermark."
          },
          "return_last_frame": {
            "type": "boolean",
            "default": false,
            "description": "Whether to return the last frame as a separate image."
          }
        },
        "x-order-properties": [
          "model",
          "draft_id",
          "output_format",
          "watermark",
          "return_last_frame"
        ]
      },
      "PredictionData": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "description": "Unique identifier for the prediction."
          },
          "urls": {
            "type": "object",
            "description": "Object containing related API endpoints."
          },
          "model": {
            "type": "string",
            "description": "Model ID used for the prediction."
          },
          "status": {
            "type": "string",
            "description": "Status: processing, completed, failed, or timeout."
          },
          "outputs": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "URLs to generated content (video + optional last frame)."
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "description": "ISO timestamp of creation."
          },
          "completion_tokens": {
            "type": "integer",
            "description": "Tokens consumed for billing."
          },
          "total_tokens": {
            "type": "integer",
            "description": "Total tokens consumed."
          },
          "draft_id": {
            "type": "string",
            "description": "The draft this task was completed from."
          }
        }
      },
      "PredictionResponse": {
        "type": "object",
        "properties": {
          "code": {
            "type": "integer"
          },
          "message": {
            "type": "string"
          },
          "data": {
            "$ref": "#/components/schemas/PredictionData"
          }
        }
      }
    },
    "securitySchemes": {
      "apiKeyAuth": {
        "in": "header",
        "name": "Authorization",
        "type": "apiKey"
      }
    }
  }
}

LLM-Friendly Prompt Template

# bytedance/seedance-2.5/draft-complete

> Render the 1080p final of a completed Seedance 2.5 draft. Prompt, inputs, duration, ratio, seed and audio come from the draft; only draft_id, return_last_frame, output_format and watermark are accepted.


## Overview

- **Submit endpoint (POST)**: `https://api.atlascloud.ai/api/v1/model/generateVideo` — start an async generation; returns a `prediction_id`
- **Poll endpoint (GET)**: `https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}` — poll this until the prediction finishes
- **Model ID**: `bytedance/seedance-2.5/draft-complete`


## API Information

This model can be used via our HTTP API or more conveniently via our client libraries.
See the input and output schema below, as well as the usage examples.


### Input Schema

The API accepts the following input parameters:

- **`model`** (`string`, _required_):
  Model name.
  - Default: `"bytedance/seedance-2.5/draft-complete"`

- **`draft_id`** (`string`, _required_):
  The id of a completed Seedance 2.5 draft (the draft's prediction id, returned as draft_id when the draft was generated with draft=true on bytedance/seedance-2.5/text-to-video, image-to-video or reference-to-video). The final is rendered at 1080p from the draft's own prompt, inputs, duration, aspect ratio, seed and audio settings; do not send those fields again. A draft can be completed any number of times within 7 days of its creation; each completion is a separate task.

- **`output_format`** (`string`, _optional_):
  Output video container format. 'mp4' is the default; 'mov' encodes yuv444p for higher color fidelity, suited to multi-round editing/extension pipelines where recompression loss accumulates.
  - Default: `"mp4"`
  - Options: "mp4", "mov"

- **`watermark`** (`boolean`, _optional_):
  Whether to add a watermark.
  - Default: `false`

- **`return_last_frame`** (`boolean`, _optional_):
  Whether to return the last frame as a separate image.
  - Default: `false`



**Required Parameters Example**:

```json
{
  "model": "bytedance/seedance-2.5/draft-complete",
  "draft_id": ""
}
```


**Full Example**:

```json
{
  "model": "bytedance/seedance-2.5/draft-complete",
  "draft_id": "",
  "output_format": "mp4",
  "watermark": false,
  "return_last_frame": false
}
```


### Output Schema

The API returns the following output format:


- **`code`** (`integer`, _optional_):

- **`message`** (`string`, _optional_):

- **`data`** (`string`, _optional_):



**Example Response**:

```json
{
  "code": 0,
  "message": "",
  "data": null
}
```


## Usage Examples

### cURL

```bash
# Step 1: Start generation (async)
curl -X POST "https://api.atlascloud.ai/api/v1/model/generateVideo" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "bytedance/seedance-2.5/draft-complete",
  "draft_id": "",
  "output_format": "mp4",
  "watermark": false,
  "return_last_frame": false
}'

# Response will contain: {"code": 200, "data": {"id": "prediction_id", "status": "processing"}}

# Step 2: Poll for result (replace {prediction_id} with the id returned above)
curl -X GET "https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY"

# Keep polling until status is "completed", "succeeded" or "failed"
# When completed, outputs will contain the generated content URL(s)
```


## Asset Library (subject reference assets)

This model supports **subject reference inputs** — upload a subject reference image to the Asset Library first, then reference it from image fields (e.g. `reference_images`, `image`, `last_image`). Instead of a regular image URL, pass `asset://<atlas_asset_id>` once the subject reference has been registered. Once an asset reaches `Active` status, it can be reused across many generation calls.

### ⚠️ Important: Different Base URL

Asset Library endpoints live on the **console** host, NOT on the inference host where generation endpoints live.

- Asset Library API: `https://console.atlascloud.ai/api/v1/sd/assets/...`
- Generation API:       `https://api.atlascloud.ai/api/v1/model/...`

Do not call `https://api.atlascloud.ai/api/v1/sd/assets` — it will return 404. Both hosts use the same `Authorization: Bearer <api-key>` header.

### Base URL

`https://console.atlascloud.ai/api/v1`

All requests require `Authorization: Bearer <api-key>`.

### Endpoints

| Method | Path | Description |
|--------|------|-------------|
| POST   | `/sd/assets`               | Create a new portrait asset from a public image URL |
| GET    | `/sd/assets/{id}`          | Get a single asset (auto-polls upstream when Processing) |
| GET    | `/sd/assets`               | List assets (paginated, supports filters) |
| PUT    | `/sd/assets/{id}`          | Rename an asset |
| DELETE | `/sd/assets/{id}`          | Move asset to trash (recoverable) |
| GET    | `/sd/assets/trash`         | List deleted assets |
| POST   | `/sd/assets/{id}/restore`  | Restore a deleted asset from trash |

### Create Asset

`POST /sd/assets`

**Body fields**:
- `url` (string, **required**): Publicly accessible image URL.
- `name` (string, optional): Display name. Max 64 characters (UTF-8 bytes).
- `asset_type` (string, optional): Default `Image`.

**Image requirements**: JPEG / PNG / WebP / BMP / TIFF / GIF / HEIC, side length 300–6000px, aspect ratio 0.4–2.5, max 30 MB.

**Example response**:
```json
{
  "code": "200",
  "data": {
    "id": 1,
    "atlas_asset_id": "asset-2026xxxx-xxxxx",
    "name": "My Portrait",
    "status": "Processing",
    "created_at": 1712467200000
  }
}
```

### Get Asset

`GET /sd/assets/{id}` — returns the asset details. If the asset is still `Processing`, the API automatically checks the upstream status and returns the latest state, so clients only need to poll this single endpoint.

### List Assets

`GET /sd/assets`

**Query parameters**:
- `page_number` (int): Page number, default `1`.
- `page_size` (int): Results per page, default `20`, max `100`.
- `status` (string): Filter — one of `Processing`, `Active`, `Failed`.
- `name` (string): Fuzzy search by name.
- `created_from` (int64): Created at or after this unix-millis timestamp.
- `created_to` (int64): Created at or before this unix-millis timestamp.

### Update Asset

`PUT /sd/assets/{id}` — body: `{ "name": "new name" }` (max 64 chars).

### Delete & Restore

- `DELETE /sd/assets/{id}` — moves the asset to trash. The asset is hidden from list endpoints but can be restored later.
- `GET /sd/assets/trash` — lists deleted assets. Same `page_number` / `page_size` / `name` filters as the regular list endpoint.
- `POST /sd/assets/{id}/restore` — restores a deleted asset from trash.

### Asset Lifecycle

```
Create → Processing → Active   (ready for video generation)
                    → Failed   (check error_code / error_message)
```

- **Processing** — Image is being preprocessed. Poll `GET /sd/assets/{id}` until it transitions.
- **Active** — Ready to use. Reference it as `asset://<atlas_asset_id>` in any image field of a video generation request.
- **Failed** — Preprocessing failed. Inspect `error_code` and `error_message` on the asset (e.g. unsupported format, oversized image, no face detected).

### Quick Start (cURL)

```bash
# 1. Create an asset
curl -X POST https://console.atlascloud.ai/api/v1/sd/assets \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/portrait.jpg", "name": "My Portrait"}'

# 2. Poll until status is "Active"
curl https://console.atlascloud.ai/api/v1/sd/assets/1 \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY"

# 3. Use the atlas_asset_id in a video generation request
#    Pass it in any image field as: asset://<atlas_asset_id>
```

### Using Assets in Video Generation

Once `Active`, pass `asset://<atlas_asset_id>` wherever the model schema accepts an image URL — for example in `reference_images`, `image`, or `last_image`. Example body:

```json
{
  "model": "bytedance/seedance-2.5/draft-complete",
  "prompt": "The character in image 1 dances gracefully to the music",
  "reference_images": [
    "asset://asset-2026xxxx-xxxxx"
  ]
}
```

### Error Codes

| HTTP Status | Meaning |
|-------------|---------|
| 200 | Success |
| 400 | Invalid request (e.g. malformed body, name too long, image fetch failed) |
| 401 | Missing or invalid API key |
| 404 | Asset not found |
| 500 | Server error |

### Content Review

All uploaded portraits go through automatic moderation. Non-compliant content will be blocked — not every image can be uploaded. Make sure you own the rights to the material, that it does not impersonate any real person, and that it does not violate laws, public order, or third-party intellectual property.

## Additional Resources

### Documentation

- [Model Playground](https://www.atlascloud.ai/models/bytedance/seedance-2.5/draft-complete)

No examples available

1. Introduction

Seedance 2.5 Draft Complete (bytedance/seedance-2.5/draft-complete) renders the 1080p final of a Seedance 2.5 draft. It is the second step of Seedance 2.5's two-step draft mode: first generate a fast 480p preview with draft: true on one of the three Seedance 2.5 source models, review it, then hand its draft_id to this model to obtain the full-quality render of the same shot.

Draft mode is offered on:

bytedance/seedance-2.5/text-to-video
bytedance/seedance-2.5/image-to-video
bytedance/seedance-2.5/reference-to-video

The final reuses everything that defined the draft — prompt, first/last frame and reference assets, duration, aspect ratio, seed, and the audio setting — so the 1080p result reproduces the preview's scene structure, shot scheduling and subject motion rather than re-rolling them.

2. Key Features & Innovations

Preview before you commit: a 480p draft renders in roughly a minute and costs the standard 480p rate, so composition, camera moves and prompt intent can be validated cheaply before the 1080p render.
Faithful completion: the final is generated from the draft task itself, not from a re-submitted prompt. Seed, duration, ratio, inputs and audio are inherited automatically; sending them again is not allowed.
Repeatable: a draft can be completed more than once within its validity window — for example once as mp4 and once as mov — each completion being a separate task.
Minimal request: the body carries only draft_id plus the delivery options output_format, watermark and return_last_frame.
Native 1080p: completions are delivered as native 1080p renders (10-bit HEVC in the upstream container), not as post-generation upscales.

3. How It Works

Submit the draft: call the source model with "draft": true. The gateway renders at 480p regardless of the resolution you send, and the prediction response carries "draft": true and a draft_id (the draft's own prediction id).
Poll the draft to completed and review the preview.
Submit the completion: call bytedance/seedance-2.5/draft-complete with that draft_id. Poll the returned prediction as usual; its response carries the draft_id it was completed from.

A draft stays completable for seven days from its creation. Completing an unknown, foreign, unfinished or deleted draft returns 400 the draft task does not exist; completing one older than seven days returns 400 the draft task has expired.

4. Request Contract

Field	Type	Notes
`model`	string, required	`bytedance/seedance-2.5/draft-complete`
`draft_id`	string, required	Prediction id of a completed draft owned by the calling account
`output_format`	`mp4` \| `mov`	Default `mp4`
`watermark`	boolean	Default `false`
`return_last_frame`	boolean	Default `false`
`webhook_url`	string	Optional completion callback, as on every video model

Any other field — including prompt, resolution, duration, ratio, seed, generate_audio and every media input — is rejected with a 400 that names the field. Resolution is always 1080p.

5. Intended Use & Applications

Iterative prompting: refine prompts across several cheap drafts, then complete only the one that works.
Storyboard review: generate drafts for every shot of a sequence, review continuity, and complete the approved shots at delivery quality.
Batch pipelines: complete approved drafts programmatically from a webhook on the draft's terminal callback.

6. Limitations

Completions inherit the draft's inputs; a different prompt, duration or ratio requires a new draft.
Only 1080p output is available for completions; the draft itself is only available at 480p.
Drafts expire seven days after creation and cannot be completed afterwards.
Draft mode is available on the three Seedance 2.5 source models above; the -esr enhancement tiers, Seedance 2.0 and the workflow wrappers do not offer it.

Seedance 2.5 Draft Complete API by ByteDance

INPUT

OUTPUT

Parameters

Code Example

Install

Authentication

HTTP Headers

Submit a request

Submit a Request

Request Body

Response

Check Status

Polling Example

Status Values

Completed Response

Upload Files

Upload Example

Response

Input Schema

Example Request Body

Output Schema

Example Response

Atlas Cloud Skills

Supported Clients

Install

Setup API Key

Capabilities

MCP Server

Supported Clients

Install

Configuration

Available Tools

API Schema

LLM-Friendly Prompt Template

1. Introduction

2. Key Features & Innovations

3. How It Works

4. Request Contract

5. Intended Use & Applications

6. Limitations

Explore Similar Models

Seedance 2.5 Reference-to-Video

Seedance 2.5 Image-to-Video

Seedance 2.5 Text-to-Video

Seedance 2.0 Mini Reference-to-Video

Seedance 2.0 Mini Image-to-Video

Seedance 2.0 Mini Text-to-Video

Avatar Omni Human 1.5

Seedance 2.0 Text-to-Video

Seedance 2.0 Fast Reference-to-Video

Seedance 2.0 Fast Image-to-Video

Seedance 2.0 Fast Text-to-Video

Seedance 2.0 Reference-to-Video

Seedance 2.0 Image-to-Video

Seedance v1.5 Pro Image-to-Video

Seedance v1.5 Pro Text-to-Video

Seedance v1.5 Pro Image-to-Video Fast

One API for All Media AI.

INPUT

OUTPUT

Parameters

Code Example

Install

Authentication

HTTP Headers

Submit a request

Submit a Request

Request Body

Response

Check Status

Polling Example

Status Values

Completed Response

Upload Files

Upload Example

Response

Input Schema

Example Request Body

Output Schema