Wan 2.6 Text to Video API

alibaba/wan-2.6/text-to-video

Wan 2.6 Text to Video transforms natural-language prompts into 5–15 second 1080p high-fidelity videos, featuring multi-shot narrative composition, cinematic camera movement, and expressive scene lighting. It faithfully preserves narrative pacing and real-world physical dynamics while sustaining temporal continuity across complex multi-angle transitions.

Input

Prompt

638/5000

Resolution

Duration

Multi Shots

OutputReady

Examples

A realistic indoor bouldering gym in bright diffuse daylight. One adult climber wearing a plain rust-red T-shirt, charcoal trousers and climbing shoes, close to the ground on a gently angled wall. In one continuous five-second side-tracking shot, the climber shifts weight onto the left foot, reaches the right hand to the next blue hold and moves one foothold sideways. Controlled modest movement, correct limb anatomy, convincing contact and body weight. Chalky wall texture, soft shoe scuff and breathing. No jumps, cuts, text, logos or music.

A realistic community kitchen in warm morning daylight. A cook in a plain pale-green apron lifts the lid of a large round bamboo steamer on a stainless counter with both hands, revealing six white steamed buns in one neat layer. One steady medium shot with a gentle push-in. Steam rises and thins naturally, the heavy lid moves as one rigid object, hands keep a secure grip. Soft lid clack, faint kitchen room tone, no dialogue or music. An ordinary shared breakfast preparation, not a product shot. No text, logos, cuts or sales imagery.

REST API Spec

Quick Start

Submit an endpoint request and poll for status. Replace example URLs with your accessible files.

Step 1: Configure API authentication

Obtain an API key from the dashboard and include Authorization: Bearer <API_KEY> in every request header.

Submission Endpoint: POSThttps://api.vidgo.ai/api/generate/submit
Auth Header: Authorization: Bearer VIDGO_API_KEY

Step 2: Submit a generation task

POST /api/generate/submit. Pass model and optional callback_url at the root level, with generation parameters inside input.

Request Payload

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "alibaba/wan-2.6/text-to-video",
  "input": {
    "prompt": "Documentary realism, dry daylight at a small archaeological dig, one adult female archaeologist in a plain sand-colored field shirt and blue neck scarf. Shot 1 [0-4s]: a wide view of the excavation grid; she kneels beside a shallow tray containing one pottery fragment. Shot 2 [4-10s]: cut to a medium close-up of the SAME woman, gently brushing dust from the fragment, then looking toward a colleague off camera and saying clearly: \"This edge belonged to a painted bowl.\" Preserve her face, clothes and location across the cut. Soft brush sounds, light outdoor breeze, natural synchronized speech. No music, titles, logos or advertising.",
    "duration": 10,
    "resolution": "720p",
    "multi_shots": 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"

Step 3: Poll for task completion

Poll status with task_id; continue while not_started or running, and stop on finished or failed. Read video URLs from data.files[].file_url on success, or data.error_message on failure.

Status Endpoint

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

Poll status using task_id; continue while not_started or running, stop when finished or failed. On success, read data.files[].file_url; on failure, read data.error_message.

not_startedrunningfinishedfailed

Submission Response

{
  "code": 200,
  "data": {
    "task_id": "W7R6RD872WMDLW7D",
    "status": "running",
    "created_time": "2026-09-21T17:09:32"
  }
}

Completed Response Data

{
  "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 end-to-end script example

Expand to view a production-ready script with retry logic, error handling, and timeout safeguards.

Complete end-to-end script example

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

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "alibaba/wan-2.6/text-to-video",
  "input": {
    "prompt": "Documentary realism, dry daylight at a small archaeological dig, one adult female archaeologist in a plain sand-colored field shirt and blue neck scarf. Shot 1 [0-4s]: a wide view of the excavation grid; she kneels beside a shallow tray containing one pottery fragment. Shot 2 [4-10s]: cut to a medium close-up of the SAME woman, gently brushing dust from the fragment, then looking toward a colleague off camera and saying clearly: \"This edge belonged to a painted bowl.\" Preserve her face, clothes and location across the cut. Soft brush sounds, light outdoor breeze, natural synchronized speech. No music, titles, logos or advertising.",
    "duration": 10,
    "resolution": "720p",
    "multi_shots": 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

Request Parameters (input object)

Supported generation parameters inside the input object when submitting a POST request to /api/generate/submit:

Field	Type	Required	Default	Description
prompt	string	Yes	—	String. Trimmed before validation; 1–5,000 Unicode characters.
duration	integer	No	5	Integer. Output duration: 5, 10, 15 seconds.
resolution	string	No	720p	Output resolution: 720p or 1080p.
multi_shots	boolean	No	—	Optional boolean. Omit to leave the upstream setting unspecified. The playground starts with false. No additional charge.

Response Fields (query result)

Task details returned when polling GET /api/generate/status/{task_id}:

Field	Type	Description
code	integer	Business response code, 200 on success.
data.task_id	string	Globally unique asynchronous task identifier.
data.status	string	Execution status: not_started, running, finished, or failed.
data.files	array	Generated video files upon completion, each with file_url and file_type.
data.error_message	string \| null	Error description if task fails.

Task Lifecycle

Clients should inspect the status field and stop polling when reaching finished or failed:

not_started
Task received and queued for execution.
running
Generation is in progress.
finished
Generation complete; retrieve video URL from data.files.
failed
Generation failed; inspect data.error_message; deducted credits are refunded per standard policy.

Polling & Error Handling

Recommended Polling IntervalStart polling every 2–3 seconds, increasing to 5 seconds as the task continues, to avoid excessive requests.
Network Fluctuations & RetriesIf status polling encounters 5xx or timeouts, the task is still running; retry querying after a brief pause.
Asynchronous Webhook CallbackProvide callback_url at the root of the request payload to receive the completed task result automatically via POST.

Specifications

Specification	Value	Description
Model ID	alibaba/wan-2.6/text-to-video	Send this value in the root-level model field.
Duration	5, 10, 15s	Default is 5 seconds.
Resolution	720p / 1080p	Default is 720p.

View the Wan 2.6 Text to Video API docs

Wan 2.6 Text to Video

Wan 2.6 Text to Video is developed by Alibaba Tongyi Lab to generate cinematic dynamic video directly from natural-language text prompts. With native support for 5, 10, or 15-second takes, 1080p high-definition output, and optional multi-shot camera sequencing, it enables creators to produce complete narrative clips without requiring initial source imagery.

Why Choose This?

Prompt-driven multi-shot storytellingStructure story beats with natural language and enable multi_shots for automated multi-angle scene progression in a single run.
Up to 1080p native full HDChoose between 720p and 1080p resolutions to render subtle facial expressions, fabric textures, and dynamic environment lighting.
Flexible 5–15 second durationsGenerate 5, 10, or 15-second clips to accommodate everything from quick concept boards to sustained narrative takes.
Coherent physical motion simulationBuilt on Diffusion Transformer architecture to simulate realistic fluid flow, gravity, cloth movement, and character kinetics.
Seamless API integration and playgroundTest prompts in the web playground or deploy via REST API with asynchronous job submission, polling, and webhook support.

Parameters

Parameter	Requirement	Description
prompt	Required	String. Trimmed before validation; 1–5,000 Unicode characters.
duration	Optional	Integer. Output duration: 5, 10, 15 seconds. Default`51015`
resolution	Optional	Output resolution: 720p or 1080p. Default`720p1080p`
multi_shots	Optional	Optional boolean. Omit to leave the upstream setting unspecified. The playground starts with false. No additional charge. `truefalse`

How to Use

Draft your text promptDescribe the subject, environment, action sequence, and camera movement in prompt, supporting 1–5,000 characters.
Select output durationChoose a duration of 5, 10, or 15 seconds depending on your scene requirements, with 5 seconds as default.
Choose resolution tierPick 720p for fast exploration or 1080p for final production delivery, with 720p as default.
Optionally enable multi-shotSet multi_shots to true to introduce multi-angle cinematography without any additional cost.
Verify credits and submitCheck the estimated cost and click Run, or send a POST request to /api/generate/submit.
Track task progressPoll the status endpoint with task_id until status reaches finished to retrieve your download URL.
Preview and downloadWatch the generated video directly in the playground player and download the MP4 file.

Pricing

Billed per generated video by output resolution and duration. Multiple shots do not add a surcharge. 1 credit = $0.005.

Usage	Rate	Details
720p · 5 seconds	80 credits / $0.40	Per video
720p · 10 seconds	160 credits / $0.80	Per video
720p · 15 seconds	240 credits / $1.20	Per video
1080p · 5 seconds	120 credits / $0.60	Per video
1080p · 10 seconds	240 credits / $1.20	Per video
1080p · 15 seconds	360 credits / $1.80	Per video

Best Use Cases

Cinematic storyboards and previsualizationTurn screenplays into dynamic previs reels with multi-shot staging to test blocking and timing.
Digital advertising and product promosProduce high-impact 1080p commercials and social clips from narrative and lifestyle descriptions.
Short-form drama and narrative contentDevelop scripted dialogue moments and sequential dramatic action across sustained 15-second takes.
Natural landscapes and atmosphere reelsDepict atmospheric changes such as sunrise, ocean swell, or mountain mists with organic light physics.
Artistic VFX and visual concept explorationExplore surreal concepts and fantastical creatures with stable physical motion and lighting.

Pro Tips

Structure prompts by layers: Organize descriptions into subject details, environment, action chronology, camera motion, and lighting style for optimal model comprehension.
Leverage multi_shots for scene progression: When describing sequence changes like close-up to wide shot, set multi_shots=true to trigger natural multi-angle framing.
Align duration with scene scope: Use 5 seconds for a single punchy beat, and choose 10 or 15 seconds when characters perform multi-phase actions.
Use standard cinematography terms: Direct the lens with precise cues like slow push-in, orbital tracking, or low-angle pedestal for predictable camera movement.
Specify lighting and atmosphere: Mention soft backlight, morning mist rays, or diffused ambient bounce to bring out photorealistic 1080p textures.

Notes

Prompt input specifications: This endpoint is text-only; prompt accepts 1–5,000 Unicode characters after trimming surrounding whitespace.
Duration and resolution tiers: Supports 5, 10, and 15 seconds at 720p (default) or 1080p, billed according to selected duration and resolution.
No surcharge for multi-shot mode: The multi_shots parameter is an optional boolean; enabling it does not add any credit cost.
Asynchronous task handling: Save the returned task_id to poll generation progress or configure callback_url for automated webhook delivery.

Wan 2.6 Text to Video API Frequently Asked Questions

What is the Wan 2.6 Text to Video API?

Wan 2.6 Text to Video is an Alibaba model for text-to-video generation. It transforms natural-language text prompts into 5–15 second, up to 1080p high-definition dynamic videos with support for cinematic camera movement and multi-shot narrative composition. Built on an advanced Diffusion Transformer spatio-temporal architecture, it faithfully preserves prompt physics and narrative pacing while sustaining scene and subject coherence across angle changes. You can call it programmatically or try it from the playground above.

Can Wan 2.6 Text to Video generate 15-second videos?

Yes. The model supports duration tiers of 5, 10, and 15 seconds, with 5 seconds selected by default. Across a continuous 15-second sequence, it maintains stable lighting and subject morphology while executing multi-stage actions.

Does the multi-shot feature in Wan 2.6 Text to Video cost extra?

No, it carries no extra charge. The multi_shots parameter is an optional boolean; when enabled, the model automatically renders multi-angle cinematography following prompt cues, billed strictly by standard duration and resolution rates.

How do I generate 1080p video with Wan 2.6 Text to Video?

Simply specify 1080p in the resolution parameter. The 1080p tier renders crisp facial micro-expressions, hair textures, and diffuse lighting gradients, making it ideal for high-definition commercial deliverables.

Does Wan 2.6 Text to Video follow camera motion prompts?

Yes. Adding standard camera directions such as slow push-in, orbit shot, or low-angle tracking to your prompt guides the model to execute smooth, cinematic camera paths.

What is the prompt character limit for Wan 2.6 Text to Video?

The prompt parameter accepts 1 to 5,000 Unicode characters after trimming whitespace. It natively supports English and Chinese, offering ample space for detailed scene choreography and visual direction.

Should I use Wan 2.6 Text to Video if I already have reference images?

If you have existing artwork or photo assets, choose the Wan 2.6 Image to Video endpoint instead. Wan 2.6 Text to Video is optimized for text-only creation, whereas Image to Video anchors the initial frame to preserve facial likeness and framing.