
The Seedance 2.5 API on PoYo has two model IDs: seedance-2.5-flash for the Seedance 2.5 Flash API, released by ByteDance on November 12, 2026, and seedance-2.5 for the standard model. They share one endpoint and one request format, so the choice is a routing decision per request: resolution, number of references, cost, and how fast the result is needed. This comparison was checked against both docs pages on November 16, 2026.
Same Seedance 2.5 API request, two model IDs
Both models are submitted to POST https://api.poyo.ai/api/generate/submit and read back from GET /api/generate/status/{task_id} or a callback_url. The input fields have the same names and meanings:
| Field | seedance-2.5-flash | seedance-2.5 |
|---|---|---|
prompt | Required | Required |
duration | Required, integer 4–30 | Required, integer 4–30 |
resolution | Optional: 480p, 720p (default 720p) | Required: 480p, 720p, 1080p |
aspect_ratio | auto, 21:9, 16:9, 4:3, 1:1, 3:4, 9:16 | Same seven values |
generate_audio | Boolean, default true | Boolean |
image_urls | First frame + optional last frame; aspect_ratio auto | Same |
reference_image_urls | Up to 10 | Up to 30 |
reference_video_urls | Up to 5 | Up to 10 |
reference_audio_urls | Up to 5, needs a reference image or video | Up to 10, needs a reference image or video |
On both, image_urls cannot be combined with the reference fields, references are addressed in the prompt as @Image1, @Video1, @Audio1, and all media URLs must be public and directly downloadable. The one schema trap: resolution is optional on Flash but required on seedance-2.5. If your client relies on Flash's 720p default, add resolution explicitly before routing a request to the standard model.
Limits that differ
| Limit | Flash | Standard |
|---|---|---|
| Output resolution | 480p, 720p | 480p, 720p, 1080p |
| Duration per generation | 4–30 s | 4–30 s |
| Reference images / videos / audio | 10 / 5 / 5 | 30 / 10 / 10 (50 files max) |
| Generation speed | Nearly twice as fast, according to ByteDance | Baseline |
The Flash docs also publish per-file rules: images JPEG, PNG, or WebP up to 30 MB; reference videos MP4 or MOV, 2–30 s and up to 200 MB each, at most 30 s combined; reference audio MP3 or WAV, 2–30 s and up to 15 MB each, at most 30 s combined. The Seedance 2.5 docs page does not list per-file sizes, so do not assume a larger file allowance on the standard model.
Price per identical request
Same body, only the model ID changed. 1 credit = $0.005; generated audio is free on both.
| Request | seedance-2.5-flash | seedance-2.5 | Flash saves |
|---|---|---|---|
| 5 s, 480p | 92.5 credits ($0.4625) | 140 credits ($0.70) | 33.9% |
| 10 s, 480p | 185 credits ($0.925) | 280 credits ($1.40) | 33.9% |
| 10 s, 720p | 410 credits ($2.05) | 630 credits ($3.15) | 34.9% |
| 30 s, 720p | 1,230 credits ($6.15) | 1,890 credits ($9.45) | 34.9% |
| 30 s, 1080p | Not supported | 3,420 credits ($17.10) | — |
| 10 s, 720p + one 10 s reference video | 510 credits ($2.55) | 760 credits ($3.80) | 32.9% |
With a reference video, both models bill output seconds plus each reference video's length rounded down, at the lower with-video rate (Flash 11.5 / 25.5 credits; standard 17 / 38 / 68.5 credits at 480p / 720p / 1080p). The Seedance 2.5 API pricing post has the full table, fal's published rates, and worked workflows.
Speed: ByteDance's claim and PoYo's measured timings
ByteDance describes Seedance 2.5 Flash as delivering results close to the flagship Seedance 2.5 at nearly twice the generation speed. That is the vendor's claim; ByteDance has not published the test setup behind it on a page we could read.
What PoYo measured on November 16, 2026, end to end through the API on seedance-2.5-flash:
| Request | Time to finished |
|---|---|
| 4 s, 480p | About 2 minutes |
| 30 s, 720p | Under 3 minutes |
We have not run a matched timing test on seedance-2.5, so this post does not give a measured speedup. Times vary with load. In either case, design for async: the status docs list typical video generation at 90–300 seconds, which is too long to hold a synchronous HTTP request open.
Which model ID to call, by use case
| Use case | Model ID | Reason |
|---|---|---|
| Prompt testing, A/B variants | seedance-2.5-flash at 480p | 18.5 credits per second, the lowest Seedance 2.5 rate |
| High-volume social clips at 720p | seedance-2.5-flash | 41 vs 63 credits per second |
| User-facing generation where wait time matters | seedance-2.5-flash | ByteDance's speed claim; PoYo timings above |
| 1080p delivery | seedance-2.5 | Flash has no 1080p |
| More than 10 images, 5 videos, or 5 audio references | seedance-2.5 | Higher reference limits |
| Final render of an approved Flash draft | seedance-2.5 | Flagship model, same request body |
| Storyboards and animatics | Flash, then seedance-2.5 for hero shots | Iterate cheaply, finish on the flagship |
Route between the two model IDs in code
This router keeps one request builder for both. It sends a request to the standard model only when Flash cannot take it or when your policy marks it as a final render:
FLASH_LIMITS = {
"reference_image_urls": 10,
"reference_video_urls": 5,
"reference_audio_urls": 5,
}
def pick_model_id(input_body, final_render=False):
if input_body.get("resolution") == "1080p":
return "seedance-2.5"
for field, limit in FLASH_LIMITS.items():
if len(input_body.get(field) or []) > limit:
return "seedance-2.5"
if final_render:
return "seedance-2.5"
return "seedance-2.5-flash"
def build_request(input_body, final_render=False, callback_url=None):
body = dict(input_body)
body.setdefault("resolution", "720p") # required on seedance-2.5
request = {"model": pick_model_id(body, final_render), "input": body}
if callback_url:
request["callback_url"] = callback_url
return request
Submit the returned dict to /api/generate/submit as in the Seedance 2.5 Flash API guide, which also covers polling, callbacks, and errors.
Migration diff: promote a Flash draft to 1080p
Moving an approved draft to the standard model changes two lines:
{
- "model": "seedance-2.5-flash",
+ "model": "seedance-2.5",
"input": {
"prompt": "A paper boat drifts under a stone bridge at sunrise. Slow tracking shot.",
"duration": 10,
- "resolution": "480p",
+ "resolution": "1080p",
"aspect_ratio": "16:9"
}
}
Keep the prompt, duration, aspect ratio, and media URLs unchanged so the final render follows the same brief. The cost of that render goes from 185 credits ($0.925) at Flash 480p to 1,140 credits ($5.70) at standard 1080p. A new generation is not a frame-exact upscale of the draft, so expect differences. For how Seedance 2.5 compares with other vendors' video APIs, see Kling 4.0 vs Seedance 2.5 and MiniMax H3 vs Seedance 2.5, and the Seedance 2.5 model page for its playground.
Frequently asked questions
What is the difference between the Seedance 2.5 Flash API and the Seedance 2.5 API? Same fields and endpoint. Flash outputs 480p or 720p with up to 10 / 5 / 5 image, video, and audio references, and costs about one-third less per second. Standard adds 1080p and up to 30 / 10 / 10 references.
Can I switch from Seedance 2.5 Flash to Seedance 2.5 by changing only the model ID? Yes, as long as the request includes resolution, which is required on seedance-2.5, and stays within its limits.
Is the Seedance 2.5 Flash API faster than Seedance 2.5? ByteDance says it generates at nearly twice the speed. PoYo measured about 2 minutes for 4 s at 480p and under 3 minutes for 30 s at 720p on Flash; we have no matched timing for the standard model.
Which Seedance 2.5 API model supports 1080p? Only seedance-2.5, at 114 credits ($0.57) per second.
How many reference files does the Seedance 2.5 Flash API accept? Up to 10 images, 5 videos, and 5 audio clips per request, with reference videos and reference audio each at most 30 seconds combined.