Wan 3.0 Prime Text-to-Video API

alibaba/wan-3.0-prime/text-to-video

Wan 3.0 Prime (Text-to-Video) transforms a text prompt into a continuous video up to 30 seconds, with native audio-visual sync, layered control for action and camera, and output up to 1080p. It follows ordered beats across the shot so subject motion, scene continuity, and timing stay readable from the written plan.

Input

Prompt

537/20000

Resolution

Duration

Aspect ratio

Audio

Safety checker

Seed

Output

Idle

Your generated video will appear here

Configure the required inputs, resolution, and duration, then run the task.

Continue with

Wan 3.0 Prime Image-to-Video Wan 3.0 Prime Reference-to-Video Gemini Omni 1.1 Flash Text-to-Video MiniMax H3 Text-to-Video

Examples

Vertical 9:16, 4 seconds. A fleet of bright yellow rubber ducks paddles through a canyon of stacked rolling office chairs. Low tracking camera follows the lead duck along the chair-canyon floor. Overhead fluorescent office light, no people. Native audio: tiny plastic hulls bumping, chair-wheel squeaks, shallow water splash. No logos, no readable text, no products, no packaging, no prices, no CTA, no advertising, no watermark, no brand marks.

One continuous 4-second 4:3 shot at a rainy bus shelter. Two city pigeons in transparent plastic raincoats slap each other with their wings over a soggy bread crust. Locked medium shot, rain streaking the plexiglass. Native audio: wing slaps, pigeon coos, rain on the shelter roof, a distant bus hiss. No logos, no readable text, no products, no packaging, no prices, no CTA, no advertising, no watermark, no brand marks.

REST API

Quick Start

Authenticate, submit a valid input object, then use task_id to retrieve the video.

Connect to the Vidgo API

Create an API key, keep it only on your server, and send Authorization: Bearer VIDGO_API_KEY.

Endpoint: POSThttps://api.vidgo.ai/api/generate/submit
Authentication: Authorization: Bearer VIDGO_API_KEY

Submit one generation task

Run the smallest valid payload for this workflow. A successful submission immediately returns task_id without waiting for the video.

Submit request

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "alibaba/wan-3.0-prime/text-to-video",
  "input": {
    "prompt": "One continuous 5-second 16:9 shot in a cluttered basement laundry room. A chubby raccoon wearing oversized red headphones stands on a vibrating top-load washing machine and scratches a plain vinyl record with wet paws. Slow lateral dolly orbits the shuddering machine. Fluorescent flicker, soapy water sloshing. Native audio: washing-machine thumps, metal lid rattle, wet-paw vinyl scratches; no music bed, no speech. No logos, no readable text, no products, no packaging, no prices, no CTA, no advertising, no watermark, no brand marks.",
    "duration": 5,
    "resolution": "720p",
    "aspect_ratio": "16:9",
    "audio": true,
    "enable_safety_checker": true
  }
}
JSON
)

RESPONSE=$(curl --silent --show-error --fail-with-body \
  --request POST \
  --url "https://api.vidgo.ai/api/generate/submit" \
  --header "Authorization: Bearer $VIDGO_API_KEY" \
  --header "Content-Type: application/json" \
  --data "$REQUEST_BODY")

CODE=$(printf '%s' "$RESPONSE" | jq -r '.code // empty')
if [ "$CODE" != "0" ] && [ "$CODE" != "200" ]; then
  printf 'API error: %s
' "$RESPONSE" >&2
  exit 1
fi
printf '%s
' "$RESPONSE"

Wait for the result

Query with task_id, continue for not_started/running, and stop for finished/failed. On success, read data.files[].file_url.

Track status

GET https://api.vidgo.ai/api/generate/status/{task_id}

Poll about every 2 seconds, then back off gradually. Continue only for not_started or running and stop on finished or failed. You can instead add callback_url to the same top-level request contract.

not_startedrunningfinishedfailed

Submit response

{
  "code": 200,
  "data": {
    "task_id": "task-unified-...",
    "status": "running",
    "created_time": "2026-08-22T10:00:00Z"
  }
}

Finished response

{
  "code": 200,
  "data": {
    "task_id": "task-unified-...",
    "status": "finished",
    "files": [
      {
        "file_url": "https://storage.vidgo.ai/generated/video.mp4",
        "file_type": "video"
      }
    ],
    "created_time": "2026-08-22T10:00:00Z",
    "progress": 100,
    "error_message": null
  }
}

Complete runnable example

Expand for a complete script with HTTP and business-code checks, task_id validation, polling, terminal-state handling, and a timeout boundary.

Complete runnable example

set -euo pipefail
: "${VIDGO_API_KEY:?Set VIDGO_API_KEY in your environment}"

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "alibaba/wan-3.0-prime/text-to-video",
  "input": {
    "prompt": "One continuous 5-second 16:9 shot in a cluttered basement laundry room. A chubby raccoon wearing oversized red headphones stands on a vibrating top-load washing machine and scratches a plain vinyl record with wet paws. Slow lateral dolly orbits the shuddering machine. Fluorescent flicker, soapy water sloshing. Native audio: washing-machine thumps, metal lid rattle, wet-paw vinyl scratches; no music bed, no speech. No logos, no readable text, no products, no packaging, no prices, no CTA, no advertising, no watermark, no brand marks.",
    "duration": 5,
    "resolution": "720p",
    "aspect_ratio": "16:9",
    "audio": true,
    "enable_safety_checker": true
  }
}
JSON
)

SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  --request POST \
  --url "https://api.vidgo.ai/api/generate/submit" \
  --header "Authorization: Bearer $VIDGO_API_KEY" \
  --header "Content-Type: application/json" \
  --data "$REQUEST_BODY")

TASK_ID=$(printf '%s' "$SUBMIT_RESPONSE" | jq -r '.data.task_id // .task_id // empty')
BUSINESS_CODE=$(printf '%s' "$SUBMIT_RESPONSE" | jq -r '.code // empty')
if [ "$BUSINESS_CODE" != "0" ] && [ "$BUSINESS_CODE" != "200" ]; then
  printf 'Submit failed:
%s
' "$SUBMIT_RESPONSE" >&2
  exit 1
fi
if [ -z "$TASK_ID" ]; then
  printf 'Submit response did not include task_id:
%s
' "$SUBMIT_RESPONSE" >&2
  exit 1
fi

START_TIME=$(date +%s)
POLL_DELAY=2
while true; do
  if [ $(( $(date +%s) - START_TIME )) -ge 600 ]; then
    printf 'Timed out after 600 seconds
' >&2
    exit 1
  fi
  STATUS_RESPONSE=$(curl --silent --show-error --fail-with-body \
    --url "https://api.vidgo.ai/api/generate/status/$TASK_ID" \
    --header "Authorization: Bearer $VIDGO_API_KEY")
  STATUS=$(printf '%s' "$STATUS_RESPONSE" | jq -r '.data.status // .status // empty')
  BUSINESS_CODE=$(printf '%s' "$STATUS_RESPONSE" | jq -r '.code // empty')
  if [ "$BUSINESS_CODE" != "0" ] && [ "$BUSINESS_CODE" != "200" ]; then
    printf 'Status request failed:
%s
' "$STATUS_RESPONSE" >&2
    exit 1
  fi

  case "$STATUS" in
    finished)
      printf '%s' "$STATUS_RESPONSE" | jq -r '(.data.files // .files // [])[]?.file_url'
      break
      ;;
    failed)
      printf '%s' "$STATUS_RESPONSE" | jq -r '.data.error_message // .error_message // "Generation failed"' >&2
      exit 1
      ;;
    not_started|running)
      sleep "$POLL_DELAY"
      if [ "$POLL_DELAY" -lt 10 ]; then POLL_DELAY=$((POLL_DELAY + 1)); fi
      ;;
    *)
      printf 'Unexpected task status: %s
' "$STATUS" >&2
      exit 1
      ;;
  esac
done

Input parameters

These are the fields accepted inside input. The request example shows the required top-level model field.

Field	Type	Required	Default	Description
prompt	string	Yes	—	1–20,000 characters after trimming.
duration	integer	No	5	An integer from 2 through 30, inclusive.
resolution	string	No	720p	480p, 720p, or 1080p.
aspect_ratio	string	No	adaptive	adaptive, 16:9, 4:3, 1:1, 3:4, or 9:16.
audio	boolean	No	true	Whether to request an audio track; does not change the credit rate.
seed	integer	No	—	Optional integer from 0 through 2147483647.
enable_safety_checker	boolean	No	true	Whether to enable the safety checker.

Response Fields

Submission returns task identity immediately. Status responses add progress, every output file, or a failure message.

Field	Type	Description
code	integer	Application result code; successful responses use 0 or 200.
message	string	Human-readable message or error detail when present.
data.task_id	string	Task ID used in the status endpoint path.
data.status	string	not_started, running, finished, or failed.
data.created_time	string	Task creation time in date-time format.
data.progress	integer	Task progress from 0 to 100, when included in the response.
data.files[]	array	All output files from a successful task, in response order.
data.files[].file_url	string	Public URL for a generated video.
data.files[].file_type	string	File type, such as video.
data.error_message	string \| null	Failure detail when status is failed.

Task Lifecycle

Treat not_started and running as non-terminal states. finished and failed are terminal alternatives; stop polling when either is returned.

not_started
The task was accepted and is waiting to begin.
running
Generation is in progress. Continue polling the same task_id.
finished
Generation succeeded. Read every video URL from data.files[].file_url.
failed
Generation stopped with an error. Read data.error_message and stop polling.

Polling and Errors

AuthenticationA 401 response means the Bearer API key is missing or invalid. Correct it before retrying.
ValidationA 400 response identifies an invalid field, unsupported media key, or insufficient credit balance. Correct the request before resubmitting.
Network and timeoutA transport failure is different from a failed task. Retry status checks with a bounded timeout before deciding that the task failed.
Polling intervalStart around every 2 seconds and increase the interval gradually for a long-running task.
Terminal statesContinue only for not_started or running. Stop immediately on finished or failed.
Callback optionProvide callback_url at the request top level to receive the final flat task object; polling remains available if delivery fails.

Endpoint limits

Specification	Value	Details
Input mode	Text only	A prompt defines the scene, action, camera direction, and sound intent.
Output	Video task	The endpoint returns an asynchronous task ID.
Resolution	480p / 720p / 1080p	resolution defaults to 720p when omitted.
Duration	2–30 seconds	Every integer value in the inclusive range is valid; default is 5.
Aspect ratio	Adaptive + 5 fixed	adaptive, 16:9, 4:3, 1:1, 3:4, or 9:16.
Billing basis	Output seconds	480p uses 13.6 credits/s; 720p uses 28 credits/s; 1080p uses 56 credits/s.

View Wan 3.0 Prime Text-to-Video API documentation

Wan 3.0 Prime Text-to-Video

Wan 3.0 Prime Text-to-Video generates continuous clips with optional synchronized sound from a text prompt alone. It develops subject, setting, action order, camera language, lighting, and audio cues written in one plan so the scene advances with clear temporal continuity.

Why Choose This?

Text-to-VideoGenerate a continuous video from a written scene without uploading start frames or reference packs.
Temporal continuitySequence opening, progression, and closing beats so subject motion and scene relationships stay coherent across clips up to 30 seconds.
Layered prompt directionDescribe subject performance first, then control shot size, camera path, lighting, and atmosphere as separate layers.
Native audio syncKeep audio enabled to generate synchronized dialogue, ambience, effects, or music with the picture.
Aspect ratio controlChoose adaptive, 16:9, 4:3, 1:1, 3:4, or 9:16 before locking composition and negative space.
Delivery specsOutput 480p, 720p, or 1080p video from 2–30 seconds for draft checks and final delivery.

Parameters

Parameter	Requirement	Description
prompt	Required	String. Defines the scene, action, camera, visual treatment, and sound intent; 1–20,000 characters after trimming.
duration	Optional	Integer. Sets output length from 2 through 30 seconds, inclusive; default is 5.
resolution	Optional	String. Sets output resolution; default is 720p. `480p720p1080p`
aspect_ratio	Optional	String. Controls output framing; default is adaptive. `adaptive16:94:31:13:49:16`
audio	Optional	Boolean. Requests a generated audio track; default is true. The audio toggle does not change the credit rate. `truefalse`
seed	Optional	Integer. Optional reproducibility seed from 0 through 2147483647.
enable_safety_checker	Optional	Boolean. Enables the safety checker; default is true. `truefalse`

How to Use

Write the scene premiseOpen with the subject, setting, and visual treatment: a potter centers clay on a wheel under soft window light.
Stage ordered actionWrite concrete beats in time order: she wets the clay, lifts a tall vessel, then steadies the rim as the wheel slows.
Direct camera and soundAdd shot size, angle, and movement in a separate sentence, then note dialogue, ambience, or music cues.
Set durationChoose an integer from 2 through 30 seconds; the default is 5 for first drafts.
Choose resolutionSelect 480p for quick motion checks, or 720p / 1080p for review and delivery.
Choose aspect ratioPick adaptive, 16:9, 4:3, 1:1, 3:4, or 9:16 to match the channel framing.
Configure audioKeep audio enabled for synchronized sound; turn it off when you need a silent clip.
Generate the videoClick Run, then preview picture and sound together in the output area when the task finishes.

Pricing

Price depends only on output duration and resolution; the audio toggle does not change the rate.

Usage	Rate	Details
480p	13.6 credits/output sec ($0.068/sec)	2 seconds costs 27.2 credits ($0.136), 5 seconds costs 68 credits ($0.340), and 30 seconds costs 408 credits ($2.04).
720p	28 credits/output sec ($0.14/sec)	2 seconds costs 56 credits ($0.280), 5 seconds costs 140 credits ($0.70), and 30 seconds costs 840 credits ($4.20).
1080p	56 credits/output sec ($0.28/sec)	2 seconds costs 112 credits ($0.560), 5 seconds costs 280 credits ($1.40), and 30 seconds costs 1,680 credits ($8.40).

Best Use Cases

Campaign concept filmsTurn a written product scenario and camera plan into a concept clip for creative review before a shoot.
Storyboard previsualizationConvert a scripted beat into a motion reference for checking pacing, staging, and shot direction.
E-commerce launch teasersGenerate product storytelling clips from a launch brief for detail-page and social review.
Social channel variationsDevelop one written campaign idea into 9:16, 1:1, or 16:9 concepts for channel-specific review.
Atmosphere and music studiesTranslate lighting direction, visual progression, and sound cues into a short mood film.

Pro Tips

Structure the prompt as duration and aspect intent, subject and assets, scene and lighting, camera and shot, dialogue and sound, then timeline.
Replace a thin prompt such as 'a boutique opens' with a visible beat: staff unlock the door, warm lights rise, and the camera tracks past the display table.
Keep subject movement and camera movement in separate sentences so each instruction has a clear role.
Use first, then, and finally when several actions need a readable sequence inside a longer take.
Validate motion and timing at 480p / 5 seconds, then render 1080p and longer durations once the plan holds.

Notes

Generation is asynchronous; retain task_id and stop tracking when the task reaches finished or failed.

Wan 3.0 Prime Reference-to-VideoCombine images, video, audio, documents, or webpages to keep identity across a new scene.

Wan 3.0Use the standard Wan 3.0 family for the same three workflows at a lower per-second rate.

Gemini Omni 1.1 FlashCompare prompt-driven native audio video generation from Google DeepMind.

MiniMax H3Compare a fixed 2K video family with text, frame, and multimodal reference workflows.

Wan 2.6Generate 1080p video through text, image, or video-guided workflows.

Wan 3.0 Prime Text To Video API — Frequently asked questions

What is the Wan 3.0 Prime Text-to-Video API?

Wan 3.0 Prime Text-to-Video is an Alibaba Tongyi Lab model for generating high-definition video from text. It creates high-fidelity videos up to 30 seconds at up to 1080p resolution with native synchronized audio from complex multi-layered prompts, featuring enhanced dynamic physical realism and precise cinematographic movement. Built on Wan 3.0 Prime's upgraded spatiotemporal reasoning architecture, it delivers exceptional character structural stability and natural camera fluidity across long cinematic takes. You can call it programmatically or try it from the playground above.

What performance enhancements does Wan 3.0 Prime Text-to-Video offer over Wan 3.0?

Wan 3.0 Prime delivers significant upgrades in character anatomy stability, fine-grained physics (such as liquid dynamics, fabric folds, and particles), and cinematographic lighting consistency over Wan 3.0. In complex multi-beat scenes, Prime follows layered action instructions more faithfully with reduced artifact distortion.

Can Wan 3.0 Prime Text-to-Video generate 30-second videos in a single task?

Yes. The model natively supports specifying any duration between 2 and 30 seconds (defaulting to 5 seconds). Across a 30-second single take, the model maintains consistent character identity, continuous motion trajectories, and natural temporal rhythm.

Is audio generated natively alongside video in Wan 3.0 Prime Text-to-Video?

Yes. Audio latents are co-synthesized within the multimodal diffusion framework alongside video frames. When audio is set to true (default), the model automatically infers environmental acoustics, Foley sounds, and action interactions from your prompt text.

How should I prompt multi-beat camera moves in Wan 3.0 Prime Text-to-Video?

We recommend organizing prompts into chronological stages using cues such as "first", "then", and "finally". Separate character choreography from camera movement instructions (e.g. low-angle tracking shot, slow push-in) to ensure the model executes each motion phase coherently.

Does Wan 3.0 Prime Text-to-Video support all major aspect ratios?

Yes. The model provides adaptive aspect ratio alongside 16:9 widescreen, 4:3 standard, 1:1 square, 3:4 portrait, and 9:16 vertical formats. Adaptive framing automatically selects the optimal composition based on scene content, while 9:16 targets vertical social feeds directly.

Can I draft prompts with Wan 3.0 Prime Text-to-Video in 480p to conserve credits?

Yes. The model offers 480p, 720p, and 1080p tiers. Generating at 480p consumes only 13.6 credits/s, making it ideal for verifying prompt choreography, scene staging, and camera pacing before committing to full 1080p production rendering.