Seedance 2.5 Draft Mode: Preview in 480p, Then Render the Final in 1080p

What is Seedance 2.5 draft mode?

Seedance 2.5 draft mode is a two-step way to generate a video. You first render a cheap 480p draft to check the scene, the camera, the motion and whether the model understood your prompt. If the draft works, you render a 1080p final from its task ID, reusing the same prompt, references and seed, so you only pay for 1080p once.

Most of the money in AI video goes into takes you throw away. A shot rarely works on the first try: the camera drifts, a character turns the wrong way, the product warps. Without draft mode every one of those failed tries is billed at the resolution you want to deliver in. Draft mode moves the trying to 480p and pays for 1080p once, for the take you keep.

BytePlus positions the draft as a check on four things: scene structure, shot scheduling (the camera), subject motion, and whether the model understood the prompt. Those are exactly the things that decide whether a take is usable, and none of them needs 1080p to judge.

How it works: two steps

• Step 1, the draft. Create the task with draft mode on. The draft renders at 480p only and is billed exactly like a normal 480p video.
• Step 2, the final. When the draft has finished and you like it, create the final from the draft. It renders at 1080p only and is billed like a normal 1080p video. Do this within 7 days of creating the draft.

Native 1080p, not an upscale

The final is not the draft file enlarged. Seedance 2.5 generates it again at 1080p, with 10-bit colour and H.265/HEVC encoding, from the draft's prompt, references and seed. That is why it can show detail the 480p draft never had, and also why small details can differ from the draft.

An upscaler keeps exactly what you saw, but everything it adds is inferred from 480p frames. The draft route costs more than a 480p clip plus an upscaler, and in return the model itself draws the 1080p frames. 720p is a middle ground for a single try, but a draft cannot be finalized at 720p.

What actually changed: one shot, three renders

Everything above is what BytePlus documents. This is what we measured. On 5 seconds of Seedance 2.5 we ran the same prompt three ways: straight to 1080p, as a 480p draft, and as the 1080p final rendered from that draft. Same wording every time, locked camera, sound on.

Now the same card at 1:1, with the draft blown up to the final's size so the two are comparable. This is the part that settles the upscale question.

Against a fresh 1080p generation of the same prompt, the picture is different: similarity drops to 0.62, and you can see why. The handle swaps sides, a wooden window frame appears, the jars gain labels, the whole frame warms up. That is a different take, not a sharper one.

One more number from the same run, offered as an observation rather than a benchmark: the direct 1080p render took 164 seconds, while the draft plus its final took 59 and 39. One run on shared infrastructure proves nothing about speed in general, but it does mean a draft comes back sooner than a 1080p attempt, which is the point of looking at one.

When draft mode saves credits, and when it does not

There is no separate draft price: a draft is billed as a 480p clip and a final as a 1080p clip. These are the credits AiuniVid charges on Seedance 2.5, computed with the same formula that bills your account, with sound on; reference images do not change the price. One credit is $0.01 in every credit pack.

The 1080p price is discounted until Oct 17, 2026 at 00:00 (UTC+8). A final is charged at the price in effect when you create it, not when you created the draft.

A draft costs about 25% of its final. If the very first draft is the one you keep, draft plus final costs more than going straight to 1080p (411 against 328 credits for 5 seconds). The saving starts as soon as a shot needs 2 attempts. At three attempts, going straight to 1080p costs 984 credits; three drafts and one final cost 577, 41% less. The longer the clip, the bigger the stake: a 30-second final is 1966 credits, its draft 494.

Draft workflows: short dramas, product videos, previs

• Short dramas and story clips. Blocking, expressions and dialogue timing take several tries. Iterate at 480p and pay for 1080p only for the take that plays.
• Product videos and client sign-off. Check that the product keeps its shape, colour and logo, and send the 480p draft to the client. The final is rendered from the draft they approved, not from a fresh generation that might look different.
• Long takes and previs. Seedance 2.5 generates up to 30 seconds in one go, which makes each failed long take expensive. Storyboard-to-video and game or film previs shots are the clearest case for a draft.
• Multi-character and motion-reference shots. When you hold several characters or copy motion from a reference video, a draft shows early whether faces and movement held. See keeping a character consistent across shots.
• Batches through the API. Render every shot of a series as a draft, review them, and finalize only the ones you keep.

Limits, and when to skip draft mode

• You deliver in 720p. The final is always 1080p. Generating at 720p directly is cheaper.
• The shot usually works first time. Simple shots rarely need a second try, and then draft plus final is the more expensive route.
• You will decide after 7 days. An expired draft can no longer be turned into a final.
• You are on Seedance 2.0. Among the 2.x models draft mode is a Seedance 2.5 feature; see Seedance 2.5 vs 2.0 for the other differences.
• You need the file to play in every browser. Seedance 2.5 1080p is H.265/HEVC with 10-bit colour, and some browsers only play it after download.

Moderation works the same on drafts: a draft that trips content review is refused like any other clip, and failed generations return their credits either way.

Draft mode vs testing on a cheaper model

Another common approach is to test a prompt on a cheaper model and run the winner on Seedance 2.5. A 5-second 480p test costs 12 credits on Seedance 2.0 Mini and 28 on 2.0 Fast, against 83 for a Seedance 2.5 draft. The difference is what carries over. A test on another model checks the prompt: the 2.5 render afterwards is a new generation by a different model, so composition, motion and timing start over. A 2.5 draft checks the shot itself, because the final reuses its inputs and seed. Explore ideas on a cheaper model; switch to draft mode once you are choosing between takes.

Seedance 1.5 pro draft vs Seedance 2.5 draft

BytePlus also offers draft mode on the older Seedance 1.5 pro, which is why some guides and search suggestions mention it. The two work differently:

How to use Seedance draft mode on AiuniVid

• Open the workspace and pick Seedance 2.5. Switch on Draft; the resolution locks to 480p and the quote updates. For long shots, several references or a 1080p setting, the workspace suggests it for you.
• When the draft finishes, its card shows Render 1080P final with the credit cost. One click starts the final; it appears in your creations as a new card marked Final 1080P.
• One draft makes one final on AiuniVid, so a double click can never charge twice. If the final fails, its credits come back and you can render it again.

Seedance draft mode via the API

Pass draft: true when you create the task, then call the final endpoint with the draft's task ID once it has succeeded. The final takes no body beyond an optional callback_url and metadata, because everything else comes from the draft. Full reference in the API docs.

curl --request POST \
  --url https://aiunivid.com/api/open/v1/videos/generations \
  --header "Authorization: Bearer $AIUNIVID_API_KEY" \
  --header "Idempotency-Key: $(uuidgen)" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "seedance-2.5-text-to-video",
    "prompt": "A courier hands a parcel to a surprised neighbour in a narrow hallway, handheld camera",
    "duration": 10,
    "aspect_ratio": "9:16",
    "draft": true
  }'

curl --request POST \
  --url https://aiunivid.com/api/open/v1/videos/generations/$DRAFT_TASK_ID/final \
  --header "Authorization: Bearer $AIUNIVID_API_KEY" \
  --header "Idempotency-Key: $(uuidgen)"

The same flow in Python and Node.js, polling until each task finishes. A new Idempotency-Key per request means a retry after a network error never creates a second task.

import os, time, uuid, requests

BASE = "https://aiunivid.com/api/open"
AUTH = {"Authorization": f"Bearer {os.environ['AIUNIVID_API_KEY']}"}

def post(path, body=None):
    headers = {**AUTH, "Idempotency-Key": str(uuid.uuid4())}
    res = requests.post(BASE + path, json=body or {}, headers=headers, timeout=60)
    res.raise_for_status()
    return res.json()

def wait(task_id):
    while True:
        task = requests.get(f"{BASE}/v1/videos/generations/{task_id}", headers=AUTH, timeout=60).json()
        if task["status"] in ("succeeded", "failed", "cancelled"):
            return task
        time.sleep(15)

draft = wait(post("/v1/videos/generations", {
    "model": "seedance-2.5-text-to-video",
    "prompt": "A courier hands a parcel to a surprised neighbour in a narrow hallway, handheld camera",
    "duration": 10,
    "aspect_ratio": "9:16",
    "draft": True,
})["id"])
print("draft", draft["status"], draft["result"] and draft["result"]["download_url"])

# Only if you like the draft:
final = wait(post(f"/v1/videos/generations/{draft['id']}/final")["id"])
print("final", final["status"], final["result"] and final["result"]["download_url"])

import { randomUUID } from "node:crypto";

const BASE = "https://aiunivid.com/api/open";
const AUTH = { Authorization: `Bearer ${process.env.AIUNIVID_API_KEY}` };

async function post(path, body = {}) {
  const res = await fetch(BASE + path, {
    method: "POST",
    headers: { ...AUTH, "Content-Type": "application/json", "Idempotency-Key": randomUUID() },
    body: JSON.stringify(body),
  });
  const data = await res.json();
  if (!res.ok) throw new Error(`${data.error?.code}: ${data.error?.message}`);
  return data;
}

async function wait(id) {
  for (;;) {
    const task = await (await fetch(`${BASE}/v1/videos/generations/${id}`, { headers: AUTH })).json();
    if (["succeeded", "failed", "cancelled"].includes(task.status)) return task;
    await new Promise((resolve) => setTimeout(resolve, 15_000));
  }
}

const draft = await wait((await post("/v1/videos/generations", {
  model: "seedance-2.5-text-to-video",
  prompt: "A courier hands a parcel to a surprised neighbour in a narrow hallway, handheld camera",
  duration: 10,
  aspect_ratio: "9:16",
  draft: true,
})).id);
console.log("draft", draft.status, draft.result?.download_url);

// Only if you like the draft:
const final = await wait((await post(`/v1/videos/generations/${draft.id}/final`)).id);
console.log("final", final.status, final.result?.download_url);

Draft tasks carry draft: true and draft_expires_at (Unix seconds); finals carry draft_id. Errors to handle:

Frequently asked questions

Sources

• BytePlus ModelArk · Dreamina Seedance 2.5 tutorial: Draft mode
• BytePlus ModelArk · Create a video generation task (API reference)
• BytePlus ModelArk · Video generation tutorial (Seedance 1.5 pro draft mode)