Wan 3.0 Prime Video Extend

Wan 3.0 Prime Video Extend continues an existing video with a new AI-generated segment while preserving the visual and audio context of the source footage. Instead of regenerating the original clip, it keeps the retained source intact and generates what happens next, making it suitable for longer narrative sequences, continuous camera movement, character actions, and scene progression.

Why Choose This?

Continuous video extension
Continue an existing clip instead of generating an unrelated new shot, helping maintain scene, subject, and motion continuity.
Up to 120 seconds of source context
The model can retain and use up to the last 120 seconds of the source video before generating the continuation.
2–30 second new segments
Append a newly generated segment from 2 to 30 seconds in a single request.
Prime generation quality
Designed for higher-quality continuation workflows where visual coherence, motion progression, and scene continuity matter.
Optional ending-frame control
Use last_image to guide the final appearance or composition of the newly generated segment.
Audio-aware continuation
Existing source audio is preserved, while enable_audio can generate audio for the newly appended segment.
480p, 720p, and 1080p output
Choose the resolution that best fits preview, production, or higher-quality workflows.
Prompt expansion
Enable automatic prompt optimization when the continuation requires more detailed motion or scene interpretation.

Parameters

Parameter	Required	Description
prompt	Yes	Positive prompt describing how the video should continue, including subject action, scene progression, camera movement, atmosphere, and visual direction.
video	Yes	Source video URL. Inputs longer than `120` seconds are automatically trimmed to their last `120` seconds before extension.
last_image	No	Optional last-frame image used to guide the ending of the generated continuation. Supports URL or Base64-encoded data.
resolution	No	Output video resolution: `480p`, `720p`, or `1080p`. Default: `720p`.
duration	No	Length of the new segment to append, in seconds. Range: `2–30`. Default: `5`.
enable_prompt_expansion	No	Enable automatic prompt optimization and expansion. Default: `false`.
enable_audio	No	Generate audio for the newly appended segment. Existing source audio is preserved. Default: `true`.
seed	No	Random seed for generation. Use `-1` for a random seed.

How to Use

Upload a source video — Provide the clip you want to continue.
Describe what happens next — Write a prompt focused on the continuation rather than repeating the existing scene.
Add last-frame guidance optional — Provide last_image when the continuation should end on a specific composition, pose, or scene state.
Choose resolution — Select 480p, 720p, or 1080p.
Set extension duration — Choose how many new seconds to append, from 2 to 30.
Configure prompt expansion optional — Enable enable_prompt_expansion when the continuation instruction needs additional interpretation.
Configure audio optional — Keep enable_audio enabled when the generated segment should include new audio.
Set seed optional — Use a fixed seed for reproducible generation, or -1 for random generation.
Submit — Generate the extended video and retrieve the completed output.

Pricing

Pricing is based only on the newly generated extension duration and selected resolution. The retained source video duration is not included in the pricing calculation.

Resolution	Per 5s	Per Billed Second
480p	$0.375	$0.075
720p	$0.750	$0.150
1080p	$1.500	$0.300

Example Costs

Extension Duration	480p	720p	1080p
2s	$0.15	$0.30	$0.60
5s	$0.375	$0.75	$1.50
10s	$0.75	$1.50	$3.00
20s	$1.50	$3.00	$6.00
30s	$2.25	$4.50	$9.00

Best Use Cases

Narrative continuation — Extend story scenes without restarting the sequence from scratch.
Longer cinematic shots — Continue camera movement, character actions, and environmental motion beyond the original clip.
Character continuity — Extend scenes where the same subject needs to remain visually consistent across the transition.
Action progression — Continue walking, driving, dancing, combat, performance, or other ongoing motion.
Scene evolution — Progress lighting, weather, environment, or events naturally from the existing footage.
Start-to-end directed extension — Use last_image when the continuation needs to arrive at a specific final frame.
Long-form AI video workflows — Build longer sequences by repeatedly extending existing generated or edited clips.

Pro Tips

Write the prompt around what happens next, not just what is already visible in the source video.
Mention the direction of existing movement when continuity matters, such as camera tracking, character movement, or vehicle direction.
Keep character identity, clothing, environment, lighting, and camera behavior consistent in the prompt when the scene should remain continuous.
Use last_image when the continuation needs to end on a specific pose, composition, object state, or environment.
Use shorter extensions first when testing motion continuity, then increase duration once the direction is stable.
Enable enable_prompt_expansion for short prompts that need more detailed interpretation.
Use a fixed seed when comparing different prompts or parameter configurations.

Notes

video and prompt are required.
duration controls only the length of the newly generated segment.
Extension duration supports 2–30 seconds and defaults to 5.
Source videos longer than 120 seconds are automatically trimmed to their last 120 seconds.
Existing source audio is preserved.
enable_audio controls audio generation for the new segment and defaults to true.
enable_prompt_expansion defaults to false.

Related Models

Wan 3.0 Prime Image-to-Video — Generate Prime-quality video from a first-frame image.
Wan 3.0 Image-to-Video — Generate video from a first-frame image with optional last-frame guidance.
Wan 3.0 Reference-to-Video — Generate video using multimodal reference images, video, and audio.
Wan 3.0 Text-to-Video — Generate video directly from natural-language prompts.

Wan 3.0 Prime Video Extend API — Quick start

Grab a WaveSpeedAI API key, then call POST https://api.wavespeed.ai/api/v3/alibaba/wan-3.0-prime/video-extend 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 Wan 3.0 Prime Video Extend 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",
    "video": "https://interactive-examples.mdn.mozilla.net/media/cc0-videos/flower.mp4",
    "resolution": "720p",
    "duration": 5,
    "enable_prompt_expansion": false,
    "enable_audio": true
}
JSON
)

# 1. Submit the prediction.
SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  -X POST "https://api.wavespeed.ai/api/v3/alibaba/wan-3.0-prime/video-extend" \
  -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/alibaba/wan-3.0-prime/video-extend";
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",
        "video": "https://interactive-examples.mdn.mozilla.net/media/cc0-videos/flower.mp4",
        "resolution": "720p",
        "duration": 5,
        "enable_prompt_expansion": false,
        "enable_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",
    "video": "https://interactive-examples.mdn.mozilla.net/media/cc0-videos/flower.mp4",
    "resolution": "720p",
    "duration": 5,
    "enable_prompt_expansion": False,
    "enable_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/alibaba/wan-3.0-prime/video-extend", 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)

Wan 3.0 Prime Video Extend API — Frequently asked questions

What is the Wan 3.0 Prime Video Extend API?

Wan 3.0 Prime Video Extend is a Alibaba model for video extension, exposed as a REST API on WaveSpeedAI. Wan 3.0 Prime Video Extend continues existing videos by generating a new 2-30 second segment from the final frame and appending it to the retained source video. It preserves existing source audio, supports optional audio generation for the new segment, retains up to the last 120 seconds of input, and outputs at 480P / 720P / 1080P. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing. You can call it programmatically or try it from the playground above.

How do I call the Wan 3.0 Prime Video Extend 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 production-oriented Python, JavaScript, and cURL examples with timeouts, transient-error handling, and safe GET retries. Full request/response shape is documented at https://wavespeed.ai/docs/docs-api/alibaba/alibaba-wan-3.0-prime-video-extend.

How much does Wan 3.0 Prime Video Extend cost per run?

Wan 3.0 Prime Video Extend starts at $0.75 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 Wan 3.0 Prime Video Extend accept?

Key inputs: `prompt`, `video`, `resolution`, `duration`, `seed`, `enable_audio`. 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/alibaba/alibaba-wan-3.0-prime-video-extend.

How do I get started with the Wan 3.0 Prime Video Extend API?

Sign up for a free WaveSpeedAI account to claim starter credits, copy your API key from /accesskey, then call the endpoint shown in the API tab of the playground. The playground also auto-generates a code sample in Python, JavaScript, or cURL for the parameters you've set.

Can I use Wan 3.0 Prime Video Extend outputs commercially?

Commercial usage rights depend on the model's license, set by its provider (Alibaba). The license summary appears on the model card above; see WaveSpeedAI's Terms of Service for platform-level conditions.

alibaba/

ExamplesView all

Related Models

README