Seedance 2.5 API: access, pricing and code examples
You can call Seedance 2.5 today through third-party API providers such as Kie and fal. On October 3, 2026, Kie listed $0.14 per second at 480p and $0.315 at 720p, and fal listed about $0.22 and $0.47. A request is one asynchronous job: create a task, then poll or receive a callback.
Kie is the cheaper of the two routes we reviewed and uses one request shape for text, image and reference inputs. fal splits those into three endpoints and ships a queue SDK. Keep either one behind your own server-side adapter.
Kie price
$0.14 to $0.79 per second
480p, 720p and 1080p without video input.
fal price
$0.22 to $0.47 per second
Dated 480p/720p examples; 1080p is also accepted by the current API schema.
Duration
4 to 30 seconds
One clip per task.
Task pattern
Asynchronous
Create, then poll or use a callback.
Checked October 3, 2026
How much does the Seedance 2.5 API cost?
API pricing is per second of video and rises with resolution. When you pass a reference video, Kie bills a lower unit price on input plus output seconds, so a long reference clip can cost more than a text-only request.
| Provider and mode | 480p per second | 720p per second | 1080p per second |
|---|---|---|---|
| Kie, no video input | $0.14 | $0.315 | $0.79 |
| Kie, with video input (input plus output seconds) | $0.085 | $0.19 | $0.475 |
| fal, no video input | $0.2205 | $0.473 | Supported; check live pricing |
Workspace credits are a separate price
These are provider API prices for developers. The browser workspace on this site charges product credits, listed on the pricing page.
Quick start
Seedance 2.5 API example with curl
Create a task with one POST request. The response returns a task ID immediately; the video is produced in the background.
Create a task
curl -X POST https://api.kie.ai/api/v1/jobs/createTask \
-H "Authorization: Bearer $KIE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "bytedance/seedance-2-5",
"callBackUrl": "https://your-domain.com/api/seedance/callback",
"input": {
"prompt": "A ceramic artist lifts a cobalt bowl into window light, slow dolly in.",
"resolution": "720p",
"duration": 5,
"aspect_ratio": "16:9",
"generate_audio": true
}
}'Response
{ "code": 200, "msg": "success", "data": { "taskId": "task_bytedance_..." } }Check the task
curl "https://api.kie.ai/api/v1/jobs/recordInfo?taskId=$TASK_ID" \ -H "Authorization: Bearer $KIE_API_KEY"
Polling loop
Seedance 2.5 API example in Python
Illustrative server-side code, not a live request result. It bounds HTTP and polling time, checks provider errors, and keeps the task ID when a job is still running. Never resubmit automatically after an unknown outcome.
Python with requests
import os, time, requests
BASE = "https://api.kie.ai/api/v1/jobs"
HEADERS = {"Authorization": f"Bearer {os.environ['KIE_API_KEY']}"}
def checked(response):
response.raise_for_status()
payload = response.json()
if payload.get("code") != 200 or not payload.get("data"):
raise RuntimeError("Provider rejected request; inspect server logs")
return payload["data"]
created = checked(requests.post(f"{BASE}/createTask", headers=HEADERS, timeout=30, json={
"model": "bytedance/seedance-2-5",
"input": {"prompt": "A ceramic artist lifts a cobalt bowl, slow dolly in.",
"resolution": "480p", "duration": 5, "aspect_ratio": "16:9"}
}))
task_id = created["taskId"] # Persist before polling. Do not create a second task.
deadline = time.monotonic() + 20 * 60
while time.monotonic() < deadline:
data = checked(requests.get(f"{BASE}/recordInfo", headers=HEADERS,
params={"taskId": task_id}, timeout=30))
if data["state"] in ("success", "fail"):
print(data["state"], data.get("resultJson") or data.get("failMsg"))
break
time.sleep(10)
else:
print("Still running or unresolved; resume polling this task:", task_id)
Unified input
Seedance 2.5 API request fields
Kie's reviewed form exposes a unified object. Your application can map text, image and reference modes into that object while omitting unused arrays rather than sending empty or contradictory fields.
| Field | Use | Validation |
|---|---|---|
| prompt | Shot description and temporal direction | Required by your product even if provider behavior varies |
| first_frame_url / last_frame_url | Opening and optional ending composition | HTTPS URL, supported image type and provider size limit |
| reference_image_urls | Character, product or style references | Provider page currently shows up to 30 files |
| reference_video_urls | Motion or scene references | Provider page currently shows up to 10; also validate total duration |
| reference_audio_urls | Audio reference material | Provider page currently shows up to 10; validate type, size and rights |
| resolution / duration / aspect_ratio | Output and cost controls | Allowlist values server-side; never trust browser input |
| nsfw_checker | Provider safety pre-check | Keep enabled, then add your own policy and review controls |
Access routes
Kie versus fal at a glance
| Area | Kie.ai | fal |
|---|---|---|
| Model routing | Unified Seedance 2.5 model and input object | Separate text-to-video, image-to-video and reference-to-video model IDs |
| Reviewed resolution fields | 480p, 720p and 1080p in the current form schema | 480p, 720p and 1080p in the text-to-video API schema |
| Reference inputs | first/last frame plus image, video and audio URL arrays | Endpoint-specific image/reference schemas |
| Duration | Numeric duration field; provider page markets up to 30 seconds | auto or 4–30 seconds in the text route documentation |
| Task handling | Task status and callback support documented by provider | Queue SDK/REST with status updates; queue recommended for longer runs |
| Pricing signal | Check account pricing and calculator | Token formula; current documentation gives approximate per-second examples |
| Best fit | One normalized Seedance integration surface | Typed endpoint separation and SDK-driven queues |
Do not generalize provider marketing
Kie and fal currently list 1080p parameters for their 2.5 routes. This browser workspace exposes only 480p/720p. Distinguish requested size, returned file dimensions and verified native generation.
Minimal request
The same request through fal
fal documents the model ID below and recommends its queue API for longer generations. In B2B use, send a stable, non-sensitive end_user_id as required by the provider—never an email or raw personal identifier.
Server-side JavaScript
import { fal } from '@fal-ai/client';
fal.config({ credentials: process.env.FAL_KEY });
const internalHashedUserId = process.env.FAL_END_USER_ID; // Stable non-personal account ID
if (!internalHashedUserId) throw new Error('Set FAL_END_USER_ID');
const result = await fal.subscribe(
'bytedance/seedance-2.5/text-to-video',
{
input: {
prompt: 'A ceramic artist lifts a cobalt bowl, slow dolly in.',
duration: '10',
resolution: '720p',
aspect_ratio: '16:9',
generate_audio: true,
end_user_id: internalHashedUserId
},
logs: true
}
);
const videoUrl = result.data.video.url;Reliability
Production integration checklist
- 01
Create your own task first
Reserve credits and persist your internal task ID before calling a provider.
- 02
Store provider identity
Save the actual provider, model ID and provider task ID so polling never guesses the route.
- 03
Use idempotency boundaries
Do not fall back to a second provider after a network timeout; the first request may already be running.
- 04
Treat failure states explicitly
Refund only on a confirmed terminal failure, not on a slow queue or temporary polling error.
- 05
Copy durable outputs
Provider result URLs may expire. Move completed videos to controlled storage according to user and provider terms.
- 06
Observe cost and latency
Log resolution, duration, provider, retries, final status and cost without recording sensitive prompts unnecessarily.
Hard requirements
API security and rights checks
- Keep Kie and fal secrets in server-side environment variables; never prefix them as public client variables.
- Validate URLs, MIME types, file sizes, counts, duration and allowlisted output settings before spending credits.
- Rate-limit by account and internal end-user ID, not only by IP address.
- Require users to have rights to every image, video, audio and character reference they submit.
- Store the provider terms/version reviewed for your commercial-use decision.
- Build moderation and appeal handling in addition to provider safety filters.
Common questions
Is there a Seedance 2.5 API?+
Yes. Seedance 2.5 is available through third-party API providers including Kie and fal. ByteDance's own international API is not offered in every country, so many developers use a reseller.
How much does the Seedance 2.5 API cost per second?+
On October 3, 2026, Kie listed $0.14 per second at 480p, $0.315 at 720p and $0.79 at 1080p without video input. fal listed about $0.22 at 480p and $0.47 at 720p.
Is there an official public ByteDance Seedance 2.5 API?+
Official access and regional availability can differ from third-party access. This guide covers current Kie and fal provider routes; verify ByteDance or BytePlus documentation separately before describing a route as official.
Should I automatically fail over from Kie to fal?+
Only before a task may have been accepted, such as a validated provider rejection. Do not resubmit after a timeout or unknown server error because both providers might generate and charge.
Can I call these APIs from the browser?+
Do not expose provider secrets in client code. Send a validated request to your own server, create an internal task, then call the provider from the server.
Sources reviewed
- Kie.ai — API pricing table, Seedance 2.5 rows
- Kie.ai — Seedance 2.5 API request reference
- Kie.ai — Seedance 2.5 API form and schema
- fal — Seedance 2.5 text-to-video API, schema and pricing
- fal — Seedance 2.5 image-to-video API
- fal — Seedance 2.5 reference-to-video API
- fal — Current text-to-video schema, including 1080p
API schemas rechecked October 12, 2026; price examples retain their October 3 snapshot date. Account pricing can change. This site provides a browser workspace and does not offer a public developer API.
Test the product workflow first
Validate prompts, settings and result handling in the browser before building your own integration.
