Seedance 2.5 Image to Video API on WaveSpeedAI

Name: Seedance 2.5 Image to Video
Brand: bytedance
SKU: bytedance/seedance-2.5/image-to-video
Price: 0.81 USD
Availability: InStock

EjemplosVer todo

Night food truck scene. The chef tosses the pan and the flames leap high, lighting up his face. He flips the sizzling food with a skilled wrist motion, plates it quickly, then leans out of the window, grins and shouts: "Order up! Careful, it's hot!" Handheld camera, sizzling oil, crackling fire, lively street ambience, warm string lights flickering.

The husky team charges across the frozen plain through a raging blizzard, snow kicking up from their paws. The explorer grips the sled, shouting "Hike! Hike! Keep going!" over the howling wind. The camera tracks alongside at ground level, then rises into a sweeping aerial shot revealing the endless white landscape and distant mountains. Epic adventure film, powerful wind, panting dogs, runners hissing on snow.

The ancient giant robot slowly awakens. Its blue eyes flare brighter, vines snap and fall from its armor, and dust pours from its joints as it takes one heavy step forward, shaking the ground and sending a flock of birds into the sunset sky. The camera starts low at its feet and tilts up to reveal its enormous scale against the ruined skyline. Deep mechanical groans, thunderous footstep, epic cinematic atmosphere.

On the surface of Mars, the female astronaut points toward the tiny blue dot of Earth in the pink sky. She says softly: "That little light is home. Everyone we have ever known is right there." The male astronaut looks up, pauses, and answers: "Then let's make them proud." A gust of wind lifts red dust around their boots. The camera slowly pushes in between them. Quiet emotional science fiction, gentle wind, subtle orchestral score.

README

Seedance 2.5 Image-to-Video

Seedance 2.5 Image-to-Video generates cinematic videos from a reference image and text prompt. It preserves the input image's subject, composition, and style while adding expressive motion, camera movement, scene progression, and synchronized audio.

Why Choose This?

Image-to-video generation
Animate a reference image into a cinematic video with prompt-guided motion.
Image-faithful results
Preserve the input image's subject identity, composition, lighting, and style while generating motion.
Optional last-frame guidance
Use last_image to guide the final frame or ending direction of the generated video.
Native audio generation
Generate synchronized audio together with the video output.
Director-style prompt control
Control camera movement, lighting, mood, subject action, and scene progression through natural-language prompts.
High-resolution output
Generate videos in 480p, 720p, 1080p, or 4k.

Parameters

Parameter	Required	Description
prompt	Yes	Detailed description of the cinematic scene, action, camera movement, lighting, and mood.
image	Yes	Start image URL to guide the video generation.
last_image	No	Last-frame image URL for video continuation or ending-frame guidance.
duration	No	Video length in seconds. Range: `4–30`. Default: `5`.
resolution	No	Output resolution: `480p`, `720p`, `1080p`, or `4k`. Default: `720p`.
generate_audio	No	Generate synchronized audio for the output video. Default: `true`.

The output aspect ratio follows the input image automatically.

How to Use

Upload a start image — Provide the image that should guide the first frame, subject, composition, and style.
Write your prompt — Describe the motion, action, camera movement, lighting, mood, and scene progression.
Add last image optional — Use last_image when you want to guide the final frame or ending direction.
Set duration — Choose a video length from 4 to 30 seconds.
Choose resolution — Select 480p, 720p, 1080p, or 4k.
Configure audio optional — Keep generate_audio enabled when synchronized audio is needed.
Submit — Generate the final image-to-video output.

Writing Effective Prompts

The input image sets the first frame — your prompt directs what happens from there. The clearer the motion and camera direction, the better the result.

1. Start from the frame

Describe the action that begins from your image: what the subject does, where it goes, how the camera moves. Don't re-describe what's already visible in the image — build on it.

The woman in the photo turns from the window and walks toward the camera; slow push-in, warm interior light.

2. Shot-by-shot timeline

For longer clips, break the motion into timed segments (1-second granularity), continuous, no gaps.

0-2s: She turns from the window, a faint smile forming. Camera holds. 2-5s: She walks toward the lens and stops mid-frame; slow push-in, shallow focus. 5-8s: She glances off-screen as light shifts from warm to cool. Handheld drift.

3. Consistency notes

Lock the look for the whole clip: camera style, lighting, palette, atmosphere, audio.

Camera language

Write these directly; the model understands them:

Shot size — extreme wide, wide, medium, medium close-up, close-up
Movement — push in, pull out, pan, track, follow, orbit, tilt up, handheld shake
Angle — low angle, overhead, eye-level, first-person
Techniques — one-shot / long take, dolly zoom, bullet time, speed ramp

For a niche term, add a plain-language gloss: "rack focus: the sharp foreground softens as the background comes into focus."

Referencing uploaded assets

When you attach images, videos, or audio, bind each one explicitly in the prompt by its upload order — @image1, @video1, @audio1 — and say what it's for. Don't rely on labels drawn inside the image itself.

"The knight in @image1 walks through the castle in @image2."
"Refer to @video1 for the camera movement only; keep its shot order."
"@image1 and @image2 are Character 1, voiced by @audio1."

When a reference is already accurate, just point to it — no need to re-describe it in detail.

Negative control

Positive descriptions work best, but you can suppress subtitles and audio:

"No subtitles."
"No BGM — ambient and action sounds only."
"No audio."

Weak vs. strong

	prompt
weak	`make it move`
strong	`The parked car in the image pulls out and drives down the wet street. 0-3s: headlights flick on, the car eases forward, reflections rippling on the asphalt. 3-6s: it accelerates past the camera, which pans to follow. Low angle, neon reflections, light rain, cinematic night mood. Engine and rain sounds, no music.`

Pricing

Pricing is based on selected resolution and duration.

Resolution	Per 5s	Per second
480p	$0.90	$0.18
720p	$1.80	$0.36
1080p	$4.50	$0.90
4k	$9.00	$1.80

Example Costs

Resolution	5s	10s	15s	30s
480p	$0.90	$1.80	$2.70	$5.40
720p	$1.80	$3.60	$5.40	$10.80
1080p	$4.50	$9.00	$13.50	$27.00
4k	$9.00	$18.00	$27.00	$54.00

Best Use Cases

Product demos — Animate product shots into cinematic showcase videos.
Ad creatives — Turn storyboard frames or campaign stills into polished commercial footage.
Character animation — Bring character art, portraits, or illustrated subjects to life with natural motion.
Scene development — Transform a single keyframe into a full cinematic sequence.
Start-and-end-frame generation — Use image and last_image to guide both the beginning and ending of the video.
Social media content — Generate short-form videos from still images for vertical, square, or landscape-style layouts.

Pro Tips

Upload high-quality reference images for stronger subject preservation.
Write prompts like a film director, including action, camera movement, lighting, mood, and atmosphere.
Use last_image when the ending frame or final visual direction matters.
Start with a short duration for quick iteration, then increase duration once the motion direction is confirmed.
Use 480p or 720p for testing and 1080p or 4k for higher-resolution output.
Describe character expressions and actions for more engaging motion.

Related Models

Seedance 2.5 Text-to-Video — Generate video from text prompts alone.
Seedance 2.5 Video Edit — Edit an existing video with a prompt.
Seedance 2.5 Video Extend — Extend an existing video with a new segment.
Seedance 2.0 Image-to-Video — Previous-generation Seedance image-to-video model.

Seedance 2.5 Image To Video API — Quick start

Grab a WaveSpeedAI API key, then call POST https://api.wavespeed.ai/api/v3/bytedance/seedance-2.5/image-to-video with your input as JSON. The endpoint returns a prediction id. Start polling the result endpoint around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. On completed, read output values from data.outputs. Examples for Seedance 2.5 Image To Video below.

HTTP example

set -euo pipefail

: "${WAVESPEED_API_KEY:?Set WAVESPEED_API_KEY}"

REQUEST_BODY=$(cat <<'JSON'
{
    "prompt": "A cinematic shot of a city at sunset, soft golden light",
    "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
    "resolution": "720p",
    "duration": 5,
    "generate_audio": true
}
JSON
)

# 1. Submit the prediction.
SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  -X POST "https://api.wavespeed.ai/api/v3/bytedance/seedance-2.5/image-to-video" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $WAVESPEED_API_KEY" \
  -d "$REQUEST_BODY")

TASK=$(printf '%s' "$SUBMIT_RESPONSE" | jq 'if has("data") then .data else . end')
PREDICTION_ID=$(printf '%s' "$TASK" | jq -r '.id')
if [ -z "$PREDICTION_ID" ] || [ "$PREDICTION_ID" = "null" ]; then
  printf 'Submission response did not contain a prediction id
' >&2
  exit 1
fi
RESULT_URL="https://api.wavespeed.ai/api/v3/predictions/$PREDICTION_ID/result"

# 2. Poll until the prediction finishes.
while true; do
  RESPONSE=$(curl --silent --show-error --fail-with-body "$RESULT_URL" \
    -H "Authorization: Bearer $WAVESPEED_API_KEY")
  RESULT=$(printf '%s' "$RESPONSE" | jq 'if has("data") then .data else . end')
  STATUS=$(printf '%s' "$RESULT" | jq -r '.status')
  case "$STATUS" in
    completed) printf '%s\n' "$RESULT" | jq '.outputs'; break ;;
    failed|cancelled|timeout|deleted) printf '%s\n' "$RESULT" | jq . >&2; exit 1 ;;
    *) sleep 2 ;;
  esac
done

Node.js example

const submitUrl = "https://api.wavespeed.ai/api/v3/bytedance/seedance-2.5/image-to-video";
const apiKey = process.env.WAVESPEED_API_KEY;
if (!apiKey) throw new Error('Set WAVESPEED_API_KEY');

async function requestJson(url, options = {}) {
  const response = await fetch(url, options);
  if (!response.ok) throw new Error(await response.text());
  return response.json();
}

// 1. Submit the prediction.
const body = await requestJson(submitUrl, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
        "prompt": "A cinematic shot of a city at sunset, soft golden light",
        "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
        "resolution": "720p",
        "duration": 5,
        "generate_audio": true
}),
});
const task = body.data ?? body;
if (!task.id) throw new Error("Submission response did not contain a prediction id");
const resultUrl = `https://api.wavespeed.ai/api/v3/predictions/${task.id}/result`;

// 2. Poll until the prediction finishes.
while (true) {
  const resultBody = await requestJson(resultUrl, {
    headers: { "Authorization": `Bearer ${apiKey}` },
  });
  const result = resultBody.data ?? resultBody;
  if (result.status === "completed") {
    console.log(result.outputs);
    break;
  }
  if (["failed", "cancelled", "timeout", "deleted"].includes(result.status)) throw new Error(JSON.stringify(result));
  await new Promise(resolve => setTimeout(resolve, 2000));
}

Python example

import json
import os
import time
from urllib.request import Request, urlopen

api_key = os.environ["WAVESPEED_API_KEY"]
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
payload = {
    "prompt": "A cinematic shot of a city at sunset, soft golden light",
    "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
    "resolution": "720p",
    "duration": 5,
    "generate_audio": True
}

def request_json(url, data=None):
    request = Request(url, data=data, headers=headers, method="POST" if data else "GET")
    with urlopen(request) as response:
        return json.load(response)

# 1. Submit the prediction.
body = request_json("https://api.wavespeed.ai/api/v3/bytedance/seedance-2.5/image-to-video", json.dumps(payload).encode())
task = body.get("data", body)
if not task.get("id"):
    raise RuntimeError("Submission response did not contain a prediction id")
result_url = f"https://api.wavespeed.ai/api/v3/predictions/{task['id']}/result"

# 2. Poll until the prediction finishes.
while True:
    result_body = request_json(result_url)
    result = result_body.get("data", result_body)
    status = result.get("status")
    if status == "completed":
        print(result.get("outputs", []))
        break
    if status in {"failed", "cancelled", "timeout", "deleted"}:
        raise RuntimeError(result)
    time.sleep(2)

Seedance 2.5 Image To Video API — Frequently asked questions

What is the Seedance 2.5 Image To Video API?

Seedance 2.5 Image To Video is a ByteDance model for video generation from images, exposed as a REST API on WaveSpeedAI. Seedance 2.5 (Image-to-Video) generates Hollywood-grade cinematic videos from reference images and text prompts with native audio-visual synchronization, director-level camera and lighting control, and exceptional motion stability. Built on Seed's unified multimodal architecture, it preserves the input image's subject and composition while adding expressive, physically accurate motion. You can call it programmatically or try it from the playground above.

How do I call the Seedance 2.5 Image To Video API?

POST your input parameters to the model's REST endpoint (shown in the API tab of this playground) with your WaveSpeedAI API key in the Authorization header. Submission returns a prediction ID. Poll the result endpoint starting around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. The playground generates Python, JavaScript, and cURL examples for submitting requests and polling results. Full request/response shape is documented at https://wavespeed.ai/docs/docs-api/bytedance/bytedance-seedance-2.5-image-to-video.

How much does Seedance 2.5 Image To Video cost per run?

Seedance 2.5 Image To Video starts at $0.81 per run. That figure is the base price — the final charge scales with the parameters you set in the form (output size, length, count, references, or whatever knobs this model exposes), so a higher-quality or larger output costs more than a minimal one. The exact cost for your current input is shown live next to the Generate button before you submit, and the actual per-call charge is recorded on the prediction afterwards.

What inputs does Seedance 2.5 Image To Video accept?

Key inputs: `prompt`, `image`, `resolution`, `duration`, `generate_audio`, `last_image`. The full JSON schema (types, defaults, allowed values) is rendered above the Generate button and mirrored in the API reference at https://wavespeed.ai/docs/docs-api/bytedance/bytedance-seedance-2.5-image-to-video.

How long does Seedance 2.5 Image To Video take to generate?

Reported generation time on WaveSpeedAI is around 193 seconds per request. This is an estimate, not a latency guarantee; queue time and input settings can change the total wait. live status is visible in the prediction record.

Can I use Seedance 2.5 Image To Video outputs commercially?

Commercial usage rights depend on the model's license, set by its provider (ByteDance). Check the provider's applicable terms and WaveSpeedAI's Terms of Service before commercial use.

bytedance/seedance-2.5/image-to-video