Wan 3.0 Video Prime API: Pricing, Modes, and Python Setup

Wan 3.0 Video Prime is the high-speed Wan 3.0 route on reAPI. It generates 2–30 second videos from text, first and last frames, mixed reference media, a document, or a public web page. The wire model id is wan3.0-video-prime, and jobs run asynchronously through reAPI's standard video endpoint.^[1]

Prime costs more than standard Wan 3.0, so it makes sense when waiting time matters to the product—not simply because “Prime” sounds better. There is no published fixed latency guarantee, and actual completion time still varies with duration, resolution, inputs, and service load.

TL;DR

Endpoint: POST https://reapi.ai/api/v1/videos/generations
Model: wan3.0-video-prime
Output: 2–30 seconds at 480P, 720P, or 1080P
Inputs: text, one or two frames, reference images/video/audio, one document, or one public web page
Audio: included by default; switching it off does not lower the rate
Current reAPI rates: $0.068/sec at 480P, $0.139/sec at 720P, and $0.278/sec at 1080P
Cost trap: omitted resolution defaults to 1080P, while duration: -1 reserves the 30-second ceiling

Wan 3.0 Video Prime API pricing

reAPI bills Prime by output duration and resolution. Input type does not change the per-second rate, so a ten-second document-driven video costs the same as a ten-second text-to-video job at the same resolution.^[1]

Resolution	Current rate	5 seconds	10 seconds	30 seconds
480P	$0.068/sec	$0.34	$0.68	$2.04
720P	$0.139/sec	$0.70	$1.39	$4.17
1080P	$0.278/sec	$1.39	$2.78	$8.34

These are reAPI gateway prices on August 26, 2026, not an announcement that Alibaba reduced its own prices. Check the live Wan 3.0 Video Prime model page before putting a rate into a customer-facing calculator.

For exploration, 480P keeps retries inexpensive. Move a prompt to 720P or 1080P only after the motion, timing, and reference behavior are acceptable. A higher resolution cannot repair a bad camera move or an overloaded brief.

Wan 3.0 Video Prime API modes for text, frames, references, documents, and web pages

Prime does not have a mode parameter. The fields in the request determine which workflow runs.

Workflow	Fields to send	Main constraint
Text to video	`prompt`	Prompt required
First frame	`first_frame_url`	Public image URL
First + last frame	`first_frame_url`, `last_frame_url`	Frames are ordered explicitly
Reference to video	`reference_image_urls`, `reference_video_urls`, and/or `reference_audio_urls`	At least one reference plus a prompt
Document or web page	`reference_file_urls` or `reference_link_urls`	Choose one; do not combine them

Frame fields cannot be mixed with reference_*_urls. A request that contains both a first frame and reference images is ambiguous and will be rejected. Every asset must also be reachable through a public HTTP(S) URL; base64 and data: URIs are not accepted.^[1]

The reference limits are generous but finite: up to ten images, five video clips, and five audio clips. Reference videos may total no more than 15 seconds, and their combined length plus the requested output must stay within 30 seconds. A 12-second reference video therefore leaves at most 18 seconds for the generated clip.

A working Python request

The safest first call sets duration, resolution, aspect ratio, and audio explicitly. That keeps the bill predictable and makes the request easy to reproduce.

import time

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://reapi.ai/api/v1"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

payload = {
    "model": "wan3.0-video-prime",
    "prompt": (
        "One continuous shot of a lighthouse keeper climbing a spiral "
        "staircase at dawn. The camera follows two steps behind. Warm "
        "window light crosses the walls; distant gulls and quiet surf."
    ),
    "resolution": "720P",
    "aspect_ratio": "16:9",
    "duration": 10,
    "audio": True,
}

response = requests.post(
    f"{BASE_URL}/videos/generations",
    headers=HEADERS,
    json=payload,
    timeout=30,
)
response.raise_for_status()
task_id = response.json()["id"]

deadline = time.time() + 600
while time.time() < deadline:
    status_response = requests.get(
        f"{BASE_URL}/tasks/{task_id}",
        headers=HEADERS,
        timeout=30,
    )
    status_response.raise_for_status()
    task = status_response.json()

    if task["status"] == "completed":
        print(task["output"]["video_urls"][0])
        print("credits used:", task["usage"]["credits"])
        break

    if task["status"] == "failed":
        raise RuntimeError(task.get("error") or "Generation failed")

    time.sleep(6)
else:
    raise TimeoutError(f"Task {task_id} is still processing")

Store the task id before polling. If the client process restarts, that id is enough to resume status checks without paying for another generation. A failed task is refunded automatically, but an impatient duplicate submission creates a second billable job if both succeed.^[1]

First and last frames versus reference images

Use frame mode when the opening or ending composition is non-negotiable. One image fixes the first frame; two images define the first and last frames in that order. The prompt should describe the motion between them rather than restate every visible object.

Use reference mode when an image supplies identity, wardrobe, product shape, or visual language without serving as an exact boundary frame. Name assets by their position inside each array:

{
  "model": "wan3.0-video-prime",
  "prompt": "Keep Image1 as the performer and Image2 as the coat. Use the walking pace from Video1 and the room tone from Audio1.",
  "reference_image_urls": [
    "https://cdn.example.com/performer.jpg",
    "https://cdn.example.com/coat.jpg"
  ],
  "reference_video_urls": [
    "https://cdn.example.com/walk.mov"
  ],
  "reference_audio_urls": [
    "https://cdn.example.com/room-tone.wav"
  ],
  "resolution": "720P",
  "aspect_ratio": "16:9",
  "duration": 12
}

References guide generation; they do not guarantee pixel-exact preservation. When a logo, product label, or line of text must survive unchanged, review the render as a production asset rather than assuming the input will be copied verbatim.

The two defaults most likely to waste budget

The first is resolution. Prime defaults to 1080P, the most expensive tier. A ten-second exploratory job is $2.78 at 1080P versus $0.68 at 480P. Always send the field instead of relying on the default.

The second is smart duration. Passing -1 lets the model choose the output length, but reAPI reserves the maximum 30-second cost because the final length is unknown at submission. Smart duration is useful when pacing matters more than a fixed budget. For a queue with strict spend limits, send an integer from 2 to 30.

FAQ

Is Wan 3.0 Video Prime a different model id from Wan 3.0?

Yes. Prime uses wan3.0-video-prime; standard Wan 3.0 uses wan3.0-video. Their reAPI request schemas also use different field names, so changing only the model string is not a safe migration.

Does Prime produce better video quality?

No published reAPI documentation claims a quality advantage. Prime is positioned around faster turnaround. Compare representative jobs before paying the speed premium for a production queue.

Can Prime generate a 30-second video with audio?

Yes. It supports 2–30 second output, and audio defaults to true. Generated sound still needs review for dialogue accuracy, unwanted music, clipping, and continuity.

Can I upload a PDF directly in the JSON body?

No. Upload it to a public HTTP(S) URL, then pass a one-item reference_file_urls array. Documents may be up to 100 MB and 50 pages.

How should I choose between Prime and standard Wan 3.0?

Use measured turnaround and retry cost from your own workload. The dedicated Wan 3.0 Video Prime vs Wan 3.0 comparison walks through the current price gap and migration details.

Conclusion

The Wan 3.0 Video Prime API is useful when a user-facing or time-sensitive workflow can justify a higher per-second rate. Set resolution and duration explicitly, choose one media family, save the task id, and measure real queue time before routing every job to Prime. The complete field reference is in the Prime API documentation.