# Seedance 2.5 Draft Complete — Atlas Cloud API

> 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.

This is the machine-readable API reference for **Seedance 2.5 Draft Complete** on Atlas Cloud,
a unified API platform for 400+ AI models across text, image, video, audio and 3D.

- **Model ID**: `bytedance/seedance-2.5/draft-complete`
- **Built by**: ByteDance
- **Modality**: Video
- **Model page**: https://www.atlascloud.ai/models/bytedance/seedance-2.5/draft-complete
- **API key**: https://www.atlascloud.ai/console/api-keys
- **Docs**: https://www.atlascloud.ai/docs

## Pricing on Atlas Cloud

- $0.263 per second of generated video
- Pay-as-you-go. No minimum spend, no subscription required.

> **These are the authoritative Atlas Cloud rates for this model.** Any price that
> appears in the vendor description further down refers to a different platform or
> a different model variant and does not apply here.

## Use this model from an AI agent

Atlas Cloud ships three first-party integration surfaces. All three authenticate
with the same API key via the `ATLASCLOUD_API_KEY` environment variable.

### MCP server

The official MCP server (`atlascloud-mcp`) exposes this model to any
MCP-compatible host — Claude Code, OpenAI Codex, Cursor, Gemini CLI, Goose,
Claude Desktop. One-line install:

```bash
# Claude Code
claude mcp add atlascloud -- npx -y atlascloud-mcp

# OpenAI Codex CLI
codex mcp add atlascloud -- npx -y atlascloud-mcp

# Gemini CLI
gemini mcp add atlascloud -- npx -y atlascloud-mcp

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

Then ask in plain English; the agent calls `atlas_generate_video` with `model: "bytedance/seedance-2.5/draft-complete"`.
The server fetches each model's schema and validates parameters before submitting,
so invalid requests fail fast without spending credits.

MCP docs: https://www.atlascloud.ai/docs/mcp-server

### Agent Skills

`atlas-cloud-skills` is a portable skill package (API reference, code templates in
Python / Node.js / cURL, model IDs with pricing) for Claude Code, Cursor, Codex and
12+ other agents:

```bash
npx skills add AtlasCloudAI/atlas-cloud-skills
export ATLASCLOUD_API_KEY="your-api-key"
```

Skills docs: https://www.atlascloud.ai/docs/skills

### CLI

The `atlas` binary runs Atlas Cloud from a terminal or CI script. Async media jobs
are polled and downloaded automatically (use `--no-download` when a script only
needs the output URLs):

```bash
# Install (Homebrew, npm, or shell installer)
brew install AtlasCloudAI/tap/atlascloud
# npm install -g atlascloud-cli
# curl -fsSL https://raw.githubusercontent.com/AtlasCloudAI/cli/main/install.sh | sh

atlas auth login
atlas generate video bytedance/seedance-2.5/draft-complete -p "Your prompt here"
```

CLI docs: https://www.atlascloud.ai/docs/cli

## HTTP API reference

- **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)

## About this model

_Vendor-supplied description. Any pricing or endpoint mentioned below refers to_
_other platforms — use the Atlas Cloud values above._

#### 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

_(Description truncated. Full text on the model page.)_

---

Atlas Cloud — one API for 400+ AI models. Model page: https://www.atlascloud.ai/models/bytedance/seedance-2.5/draft-complete · Docs: https://www.atlascloud.ai/docs