Seedance 2.1 is ByteDance's newest AI video generation model, the official successor to Seedance 2.0, and the fastest path to calling it in production is a platform that already wraps it behind a stable REST contract. Wireflow treats Seedance 2.1 as one node on a visual canvas, gives it a single Bearer token, and lets you call the whole pipeline as one HTTP endpoint. This guide covers the practical steps: getting an API key, choosing a workflow, submitting a prompt, handling the async execution, polling until the job finishes, and collecting the MP4 with its per-node cost.
Seedance 2.1 is built on the unified multimodal foundation introduced in 2.0, with roughly a 20% jump in overall visual quality, better rendering stability, more believable textures, and fewer artifacts. It generates up to 1080p and as high as 2K with a cinematic look, and it produces synchronized audio (ambient sound, sound effects, and character dialogue) in the same pass as the video. That single-pass audio changes how you design an API call, because there is no separate dubbing or audio post step to orchestrate afterward.
Prerequisites
Before you write any code, have the following in place. The Seedance 2.1 API page covers the model-specific parameters, but the general setup is short:
- An account with API access enabled and a funded balance, since each generation has a per-node cost.
- An API key (a Bearer token) from your dashboard.
- A workflow containing a Seedance 2.1 node, either built on the canvas or cloned from a template.
- An HTTP client:
curl, Postman, or any library in your language of choice. - A prompt. Seedance 2.1 accepts text up to about 2,000 characters and can also take a reference image as input.
To understand the model before wiring it up, the Seedance 2.1 overview explains its multi-shot narrative behavior and how it holds character, style, and environment consistent across changing camera angles.
Step 1: Generate an API Key
Open your account settings and create a new API key. This Bearer token authenticates every request and ties usage to your spend limits. Store it as an environment variable rather than hard-coding it, and rotate it if it is ever exposed. The same token works across every model in the catalog, so the key you create here also authenticates calls to a general video generation API endpoint or any other node you add later.
export WIREFLOW_API_KEY="wf_live_xxxxxxxxxxxxxxxxxxxx"
Keep this value server-side. Anything that reads the token can spend against your balance, so it should never ship in client-side code or a mobile bundle.
Step 2: Design or Choose the Seedance 2.1 Workflow
A workflow is the visual graph that the API executes. On the canvas you drop a Seedance 2.1 node, connect a prompt input, and connect its output to wherever the video should land. For a first run, a single Seedance 2.1 node with one text input is enough. The programmatic video generation platform view shows how each node exposes its own inputs, which become the JSON fields you pass at execution time.
Designing this on a canvas lets you compare models side by side. Seedance 2.1 sits next to Kling 3, Veo 3.1, and Seedance 2.0 in the same graph, so you can swap the active node without rewriting client code. If a shot later suits Veo 3.1 better, you change the node, not the integration.
Each workflow has an ID. Once your graph is saved, copy that ID; it is the path parameter you call in the next step. You can keep several saved workflows and point your code at whichever ID you need.
Step 3: Call the Execute Endpoint With Your Prompt
To run the workflow, send a POST request to the execute endpoint with your Bearer token and a JSON body. The body carries the inputs your nodes expect: at minimum the text prompt, plus an optional reference image URL. Because Seedance 2.1 turns a complex prompt into a coherent multi-shot storyboard, you can describe several beats in one prompt rather than stitching separate jobs. A Seedance API request looks like this:
curl -X POST https://www.wireflow.ai/api/v1/workflows/{workflowId}/execute \
-H "Authorization: Bearer $WIREFLOW_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"inputs": {
"prompt": "A lighthouse keeper climbs the spiral stairs at dawn, then the camera cuts to the lantern room as gulls call outside. Cinematic, soft morning light, 2K.",
"reference_image": null,
"resolution": "1080p"
}
}'
API paths like https://www.wireflow.ai/api/v1/workflows/{workflowId}/execute are called from code, not a browser, which is why they appear here as inline code.
Step 4: Handle the Async executionId
Video generation does not return instantly, so the execute call is asynchronous. Instead of waiting for the MP4, the API immediately returns an executionId and a status of QUEUED or RUNNING. This submit-then-poll pattern keeps request timeouts short and lets you fire several jobs in parallel. The response looks like this:
{
"executionId": "exec_9f3a1c2b7d",
"status": "QUEUED",
"workflowId": "wf_seedance21_shortform",
"createdAt": "2026-06-16T09:12:44Z"
}
Persist that executionId. It is the handle you use to check progress, retrieve the result, and identify the job in your cost reporting. The usage-based pricing model bills per node per execution, so this ID reconciles spend against a specific job.
Step 5: Poll Until the Status Is COMPLETED
With the executionId in hand, poll the status endpoint on an interval (every few seconds is reasonable for short clips). The status moves from QUEUED to RUNNING to COMPLETED, or to FAILED if something goes wrong. Seedance 2.1 generation is ultra-fast, so short clips resolve quickly, but you should still treat the job as asynchronous and never block a user-facing request on it. A poll uses the same Bearer token against https://www.wireflow.ai/api/v1/executions/{executionId} and returns a body like this:
{
"executionId": "exec_9f3a1c2b7d",
"status": "COMPLETED",
"nodes": [
{
"nodeId": "seedance-2-1",
"status": "COMPLETED",
"output": {
"video_url": "https://assets.wireflow.ai/out/exec_9f3a1c2b7d.mp4",
"resolution": "1080p",
"has_audio": true
},
"cost": 0.42
}
],
"totalCost": 0.42
}
Build your loop to stop on COMPLETED or FAILED, and cap the number of attempts so a stuck job does not poll forever. The AI video generator surface uses the same status shape across every video model, so one poller works whether the active node is Seedance 2.1, Kling 3, or Veo 3.1.
Step 6: Collect the MP4 and Per-Node Cost
When the status reads COMPLETED, read the video_url from the node output and download or stream the MP4. Because Seedance 2.1 writes synchronized audio in the same pass, the file already contains ambient sound, effects, and any dialogue; there is no separate audio track to merge. The cost field on each node and the totalCost at the top let you log what the run charged, the basis for any billing you pass to your own users. To benchmark spend across models first, the roundup of Seedance API tools compares how providers structure their pricing.
Single Endpoint vs Orchestrated Pipeline
There are two ways to use Seedance 2.1 through an API, and the right choice depends on how much processing happens around the video.
The single-endpoint approach is what the steps above describe: one workflow with one Seedance 2.1 node, called as one execute request. It is the simplest integration and fits cases where the prompt and reference image are all you need.
The orchestrated approach chains Seedance 2.1 with other nodes on the same canvas and still calls the whole thing as one endpoint. You might generate a reference frame with an image model such as Flux 2 Pro or Nano Banana 2, refine the prompt with an LLM step, feed the result into Seedance 2.1, then run the output through an upscaler. The graph runs under one executionId, and the cost report breaks down spend per node. A deeper comparison appears in the guide to video generation API tools.
The table below summarizes the trade-off.
| Aspect | Single Endpoint | Orchestrated Pipeline |
|---|---|---|
| Nodes per call | One Seedance 2.1 node | Multiple chained nodes |
| Setup effort | Minimal | Moderate, built on the canvas |
| Pre-processing | Prompt and reference only | Image gen, LLM prompt steps, upscaling |
| Cost reporting | Single node cost | Per-node breakdown under one execution |
| Best for | Quick clips, prototypes | Production pipelines, consistent house style |
| Model swapping | Change the one node | Change any node without touching client code |
FAQ
What is Seedance 2.1? ByteDance's newest AI video model and the official successor to Seedance 2.0. It is built on the same unified multimodal foundation and adds roughly a 20% improvement in overall visual quality, with steadier rendering, more realistic textures, and fewer artifacts.
What resolution and audio does Seedance 2.1 produce? Up to 1080p and as high as 2K with a cinematic look. It also produces synchronized audio in the same pass, including ambient sound, sound effects, and character dialogue, so there is no separate dubbing or audio post step.
Can Seedance 2.1 make multi-shot videos from one prompt? Yes. A single prompt of up to about 2,000 characters becomes a coherent multi-shot storyboard, holding character, style, and environment consistent across changing camera angles. It also accepts a reference image as input.
How do I get access to the Seedance 2.1 API? ByteDance exposes Seedance through its own surfaces (Dreamina, CapCut, and the enterprise clouds Volcano Engine and BytePlus). Most developers outside China reach it through a third-party API provider that wraps it behind a standard REST endpoint, the approach this guide follows.
Why is the API call asynchronous?
Video generation takes longer than a normal HTTP request should wait, so the execute call returns an executionId immediately and you poll for the result. This keeps request timeouts short and lets you run several jobs at once.
How is Seedance 2.1 usage priced?
Per node per execution. Each response includes a cost value on every node and a totalCost for the run, so you can reconcile what a job charged and set account spend limits to cap usage.
Can I compare Seedance 2.1 with other video models? Yes. On a visual canvas it sits beside Kling 3, Veo 3.1, and Seedance 2.0, so you can swap the active node and run the same prompt through different models without changing your client code.
How fast is Seedance 2.1? Generation is described as ultra-fast and quicker than Seedance 2.0. Short clips usually resolve quickly, though you should still treat every job as asynchronous and poll for completion.
Conclusion
Calling Seedance 2.1 through an API comes down to six repeatable steps: create a key, choose a workflow, submit a prompt to the execute endpoint, capture the executionId, poll until the status is COMPLETED, and collect the MP4 with its per-node cost. The model handles the hard parts (up-to-2K cinematic output, synchronized audio in one pass, multi-shot consistency from a single prompt) while the API handles submission, polling, and cost reporting. On a node-based platform you can start with one node today and grow into a chained pipeline without rewriting your integration, swapping models as new ones arrive. When you are ready to wire it in, the Seedance 2.1 API reference has the model-specific parameters to get your first request running.
