Skip to content
Developer guideSchema reviewed October 12, 2026 · prices dated October 3

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.

01

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 mode480p per second720p per second1080p 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.473Supported; 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.

02

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"
03

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)
04

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.

FieldUseValidation
promptShot description and temporal directionRequired by your product even if provider behavior varies
first_frame_url / last_frame_urlOpening and optional ending compositionHTTPS URL, supported image type and provider size limit
reference_image_urlsCharacter, product or style referencesProvider page currently shows up to 30 files
reference_video_urlsMotion or scene referencesProvider page currently shows up to 10; also validate total duration
reference_audio_urlsAudio reference materialProvider page currently shows up to 10; validate type, size and rights
resolution / duration / aspect_ratioOutput and cost controlsAllowlist values server-side; never trust browser input
nsfw_checkerProvider safety pre-checkKeep enabled, then add your own policy and review controls
05

Access routes

Kie versus fal at a glance

AreaKie.aifal
Model routingUnified Seedance 2.5 model and input objectSeparate text-to-video, image-to-video and reference-to-video model IDs
Reviewed resolution fields480p, 720p and 1080p in the current form schema480p, 720p and 1080p in the text-to-video API schema
Reference inputsfirst/last frame plus image, video and audio URL arraysEndpoint-specific image/reference schemas
DurationNumeric duration field; provider page markets up to 30 secondsauto or 4–30 seconds in the text route documentation
Task handlingTask status and callback support documented by providerQueue SDK/REST with status updates; queue recommended for longer runs
Pricing signalCheck account pricing and calculatorToken formula; current documentation gives approximate per-second examples
Best fitOne normalized Seedance integration surfaceTyped 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.

06

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;
07

Reliability

Production integration checklist

  1. 01

    Create your own task first

    Reserve credits and persist your internal task ID before calling a provider.

  2. 02

    Store provider identity

    Save the actual provider, model ID and provider task ID so polling never guesses the route.

  3. 03

    Use idempotency boundaries

    Do not fall back to a second provider after a network timeout; the first request may already be running.

  4. 04

    Treat failure states explicitly

    Refund only on a confirmed terminal failure, not on a slow queue or temporary polling error.

  5. 05

    Copy durable outputs

    Provider result URLs may expire. Move completed videos to controlled storage according to user and provider terms.

  6. 06

    Observe cost and latency

    Log resolution, duration, provider, retries, final status and cost without recording sensitive prompts unnecessarily.

08

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.
FAQ

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

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.

Open the generator