How to Use Seedance 2.5 Draft Mode on Makernice

Seedance 2.5 Draft mode lets you check a shot as a cheap 480p draft before you pay for a 1080p final of the same shot. On Makernice, you make a draft with Seedance 2.5, ByteDance's video model, by adding draft: true to a normal request or by turning on the Draft switch in the web tool. Within 3 days, you turn that draft into a 1080p final: Seedance 2.5 reuses the draft's parameters to render a 1080p version of the same shot, keeping the details consistent with the draft.

What is Seedance 2.5 Draft mode?

Seedance 2.5 Draft mode is a two-step way to make a video: first a 480p draft to check the shot, then a 1080p final rendered from that draft with the same settings. The flow comes from ByteDance, and BytePlus, ByteDance's cloud platform, documents it for Seedance 2.5 only. Seedance 2.0 and Seedance 2.0 Fast don't have it. On Makernice, the same two steps work in the API and in the web tool for Seedance 2.5. Other models reject the draft field.

How do you turn on Draft mode in the API?

A draft is a normal Seedance 2.5 generation with one extra field: draft: true. The resolution must be 480p; any other resolution returns 400 draft_requires_480p. Quote it like any other generation, then create it with the quote id, the same input and an Idempotency-Key, as in the Seedance 2.5 API tutorial.

curl https://api.makernice.com/v1/generations/quote \
  -H "Authorization: Bearer $MAKERNICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.5",
    "mode": "t2v",
    "prompt": "A red kite climbs over a windy beach at sunrise, slow tracking shot, long shadows on the sand",
    "duration": 5,
    "resolution": "480p",
    "aspect_ratio": "16:9",
    "draft": true
  }'

The quote, the hold and the charge work exactly as for a normal 480p clip. Keep the gen_ id of the draft: you need it to make the final. A draft's generation object has a draft field: draft.expires_at is the deadline for making its final, and draft.final_id is the id of its final once one is in progress or done, null until then.

How do you turn on Draft mode in the web tool?

Pick Seedance 2.5 in the Makernice web tool. A "Draft" switch appears next to the resolution. Turn it on and the resolution changes to 480p and locks, and the price shows the 480p price. Turn it off and your previous resolution comes back. Other models don't show the switch.

The Seedance 2.5 model page has the same "Draft" switch in its Playground, to the right of the resolution heading. Turn it on and the button changes to "Generate draft" with the price. When the draft is done, a "Make 1080p final" button appears below it.

When the draft is done, its card and its detail panel show how much time is left, such as "2 days left", and in your generations list it carries a "Draft mode" pill. If you're signed in and made the draft in the web tool, the console or a model page Playground, Makernice reminds you 24 hours before it expires if it has no final yet: the bell always shows "Draft expires in 24 hours" with the model name, and an email comes too only if you've turned on "Email me when a generation finishes" in settings. Drafts made through the API get no reminder; check draft.expires_at instead.

How do you turn a draft into a 1080p final?

In the API, quote a final with only two fields: model and from_draft, the gen_ id of a draft that has succeeded. Makernice copies every other setting from the draft and sets the output to 1080p.

curl https://api.makernice.com/v1/generations/quote \
  -H "Authorization: Bearer $MAKERNICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.5",
    "from_draft": "gen_..."
  }'

Then create the final with the quote id and the same two-field input. The final appears as a new generation with its own gen_ id and a source_draft_id that points to the draft; poll and download it like any other video.

curl https://api.makernice.com/v1/generations \
  -H "Authorization: Bearer $MAKERNICE_API_KEY" \
  -H "Idempotency-Key: demo-final-1842-attempt-1" \
  -H "Content-Type: application/json" \
  -d '{
    "quote_id": "qt_...",
    "input": {
      "model": "seedance-2.5",
      "from_draft": "gen_..."
    }
  }'

In the web tool, the "Make 1080p final" button is on the draft's card and in its detail panel. The button shows only on a draft that has succeeded, hasn't expired and has no final in progress or done. Click it and a confirmation dialog shows the quoted amount, "Uses the draft's settings; they can't be changed", and the expiry time.

A final request is checked when you quote it. If a check fails, the quote is refused: no generation is created and nothing is held.

How is a draft different from a normal 480p clip?

A normal 480p clip followed by a 1080p generation is two separate runs, and the 1080p run can look different, even with the same prompt and seed. A draft is the only way on Makernice to reuse the draft's parameters for a 1080p version of the same shot, keeping the details consistent. A draft costs the same as a normal 480p clip, so the only limits are the 3-day window and the fixed settings. For picking a resolution and length, see choosing resolution and duration.

How are drafts and finals charged, and what if they fail?

The draft is charged like any 480p generation: $0.1152 per second, so a 5-second draft costs $0.58. The final is a second charge at a 1080p rate for the same number of seconds, and the draft cost isn't deducted from it. The table uses price list v15 (November 11, 2026); every tier is on the pricing page.

The final column uses the public 1080p price. A final is charged at the 1080p price of the provider that made its draft, which can be higher than the public price. The final's quote shows the exact amount before anything is held. To estimate other lengths, use the video cost calculator.

A failed draft or final isn't charged: the hold is released in full. Note: if a finished output is blocked by output moderation for a policy violation, the run is still charged. You can contact support for a manual review. A final always runs on the provider that made its draft and never switches to another one; if that provider fails, the final fails and its hold is released in full. A failed final can be made again from the same draft while the draft is still valid. Every case is in Are failed generations charged?, with billing examples.

When does Seedance 2.5 Draft mode save money, and when doesn't it?

Seedance 2.5 Draft mode saves money when a shot needs two or more tries, because each extra try costs a 480p draft instead of a 1080p run. With N tries, drafts plus one final cost less than N 1080p runs whenever a 480p second costs less than (N − 1)/N of a 1080p second: less than half for 2 tries, and less than two thirds for 3 tries. At the public prices, a 480p second costs 18% of a 1080p second.

Use Draft mode when you expect to try a shot more than once: the more tries a shot needs, the more Draft mode saves. Generate 1080p directly when you expect to keep the first result. With a single try, Draft mode costs one extra 480p draft on top of the 1080p price.

Which projects is Seedance 2.5 Draft mode good for?

Seedance 2.5 Draft mode suits projects where you try many shots and keep only some of them. Three common cases:

• Short drama storyboards: make every shot of a scene as a draft, watch them in order, and make finals only of the shots that stay in the cut. To keep the same character across shots, use reference images as in keeping a character consistent across Seedance 2.5 shots.
• Product videos: check in a draft that the product stays in frame and that the camera move ends where you want, then make the final for the ad.
• Previsualization: share drafts with a client or a director to agree on framing, motion and timing before anyone pays for 1080p.

Plan every review inside the 3-day window. A draft that waits longer can't become a final, and you pay for a new draft.

Should you use Draft mode or test on Seedance 2.0 Fast first?

Use Draft mode when you want a 1080p version of the same shot that reuses the draft's parameters to keep the details consistent. Test on Seedance 2.0 Fast only when you want to check a prompt idea. A final is rendered from its draft with the draft's settings. A Seedance 2.5 run after a Seedance 2.0 Fast test is a new shot from a different model, so the framing, motion and details can change. For the differences between the two generations, see Seedance 2.5 vs Seedance 2.0.

What are the limits of Seedance 2.5 Draft mode, and when should you skip it?

Seedance 2.5 Draft mode works only with Seedance 2.5, makes only 1080p finals, and gives each draft 3 days and one successful final. The full list:

• Only Seedance 2.5 supports drafts; other models reject the draft field.
• A final is always 1080p, and there is no 4K final.
• A draft can become a final for 3 days only.
• A final can't change any setting: the prompt, images, mode, duration, aspect ratio and seed all come from the draft.
• Each draft can have one successful final; a failed final can be made again while the draft is valid.
• A final runs only on the provider that made its draft. If that provider is unavailable, the quote returns 503 draft_channel_unavailable, or the final fails and its hold is released in full.

Skip Draft mode in three cases: you need a 4K video, you expect to keep the first result, or you can't review the draft within 3 days. A normal generation at the resolution you need is the better choice in each case.

How do you use Seedance 2.5 Draft mode from Python or Node.js?

The Python and Node.js scripts below run the whole Draft mode flow: they make a 480p draft, wait for it, save it as draft.mp4, and make the 1080p final after you press Enter. Every request has a timeout, and each create call sends its own Idempotency-Key.

import os, sys, time, uuid

import requests

API = "https://api.makernice.com/v1"
H = {"Authorization": f"Bearer {os.environ['MAKERNICE_API_KEY']}"}
FINAL = ("succeeded", "failed", "canceled")


def run(job):
    # Quote, create with its own Idempotency-Key, then poll until the generation ends
    r = requests.post(f"{API}/generations/quote", json=job, headers=H, timeout=30)
    if not r.ok:
        sys.exit(f"quote {r.status_code}: {r.text}")
    quote = r.json()
    r = requests.post(f"{API}/generations", json={"quote_id": quote["id"], "input": job},
                      headers={**H, "Idempotency-Key": str(uuid.uuid4())}, timeout=30)
    if not r.ok:
        sys.exit(f"create {r.status_code}: {r.text}")
    gen = r.json()
    deadline = time.monotonic() + 30 * 60
    while gen["status"] not in FINAL:
        if time.monotonic() > deadline:
            sys.exit(f"{gen['id']} is still {gen['status']}, poll it again later")
        time.sleep(5)
        r = requests.get(f"{API}/generations/{gen['id']}", headers=H, timeout=15)
        r.raise_for_status()
        gen = r.json()
    if gen["status"] != "succeeded":
        sys.exit(f"{gen['id']} {gen['status']}: {gen.get('error')}")
    return gen


def download(gen, path):
    video = requests.get(f"{API}/generations/{gen['id']}/outputs/0", headers=H, timeout=120)
    video.raise_for_status()
    with open(path, "wb") as f:
        f.write(video.content)


# 1. Draft: a normal 480p request with "draft": True
draft = run({
    "model": "seedance-2.5",
    "mode": "t2v",
    "prompt": "A red kite climbs over a windy beach at sunrise, slow tracking shot, long shadows on the sand",
    "duration": 5,
    "resolution": "480p",
    "aspect_ratio": "16:9",
    "draft": True,
})
download(draft, "draft.mp4")
input(f"Check draft.mp4 ({draft['id']}), then press Enter to make the 1080p final ")

# 2. Final: only model and from_draft, within 3 days of the draft
final = run({"model": "seedance-2.5", "from_draft": draft["id"]})
download(final, "final.mp4")
print("Saved final.mp4")

The Node.js version does the same with the fetch built into Node.js 18 and later. The full request and response reference is in the API docs.

// Node.js 18 or later, saved as draft.mjs
import { randomUUID } from "node:crypto";
import { writeFile } from "node:fs/promises";
import { createInterface } from "node:readline/promises";

const API = "https://api.makernice.com/v1";
const H = { Authorization: "Bearer " + process.env.MAKERNICE_API_KEY, "Content-Type": "application/json" };
const FINAL = new Set(["succeeded", "failed", "canceled"]);
const REQUEST_TIMEOUT_MS = 30000;
const DOWNLOAD_TIMEOUT_MS = 120000;
const POLL_INTERVAL_MS = 5000;

async function call(method, path, body, headers = {}) {
  const res = await fetch(API + path, { signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
    method,
    headers: { ...H, ...headers },
    body: body ? JSON.stringify(body) : undefined,
  });
  if (!res.ok) throw new Error(method + " " + path + " " + res.status + ": " + (await res.text()));
  return res.json();
}

// Quote, create with its own Idempotency-Key, then poll until the generation ends
async function run(job) {
  const quote = await call("POST", "/generations/quote", job);
  let gen = await call("POST", "/generations", { quote_id: quote.id, input: job }, { "Idempotency-Key": randomUUID() });
  const deadline = Date.now() + 30 * 60 * 1000;
  while (!FINAL.has(gen.status)) {
    if (Date.now() > deadline) throw new Error(gen.id + " is still " + gen.status + ", poll it again later");
    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
    gen = await call("GET", "/generations/" + gen.id);
  }
  if (gen.status !== "succeeded") throw new Error(gen.id + " " + gen.status + ": " + JSON.stringify(gen.error));
  return gen;
}

async function download(gen, path) {
  const res = await fetch(API + "/generations/" + gen.id + "/outputs/0", { headers: H, signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
  if (!res.ok) throw new Error("download " + res.status);
  await writeFile(path, Buffer.from(await res.arrayBuffer()));
}

// 1. Draft: a normal 480p request with "draft": true
const draft = await run({
  model: "seedance-2.5",
  mode: "t2v",
  prompt: "A red kite climbs over a windy beach at sunrise, slow tracking shot, long shadows on the sand",
  duration: 5,
  resolution: "480p",
  aspect_ratio: "16:9",
  draft: true,
});
await download(draft, "draft.mp4");
const rl = createInterface({ input: process.stdin, output: process.stdout });
await rl.question("Check draft.mp4 (" + draft.id + "), then press Enter to make the 1080p final ");
rl.close();

// 2. Final: only model and from_draft, within 3 days of the draft
const final = await run({ model: "seedance-2.5", from_draft: draft.id });
await download(final, "final.mp4");
console.log("Saved final.mp4");

Where do these Seedance 2.5 Draft mode facts come from?

ByteDance's rules come from the BytePlus Seedance 2.5 documentation, read on November 11, 2026. Makernice's rules are the ones that apply to requests sent to Makernice, where they are stricter than ByteDance's.