Wan 3.0

For 2K or 4K, use the same model id. These resolutions do not support file_url, link_url or watermark: true.

Quick example

curl https://reapi.ai/api/v1/videos/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "wan3.0-video",
    "prompt": "A lighthouse keeper climbing a spiral staircase at dawn",
    "resolution": "720P",
    "size": "16:9",
    "duration": 10
  }'

import requests

resp = requests.post(
    "https://reapi.ai/api/v1/videos/generations",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "model": "wan3.0-video",
        "prompt": "A lighthouse keeper climbing a spiral staircase at dawn",
        "resolution": "720P",
        "size": "16:9",
        "duration": 10,
    },
    timeout=30,
)
print(resp.json())

const r = await fetch("https://reapi.ai/api/v1/videos/generations", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "wan3.0-video",
    prompt: "A lighthouse keeper climbing a spiral staircase at dawn",
    resolution: "720P",
    size: "16:9",
    duration: 10,
  }),
});
console.log(await r.json());

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    body, _ := json.Marshal(map[string]any{
        "model":      "wan3.0-video",
        "prompt":     "A lighthouse keeper climbing a spiral staircase at dawn",
        "resolution": "720P",
        "size":       "16:9",
        "duration":   10,
    })
    req, _ := http.NewRequest("POST",
        "https://reapi.ai/api/v1/videos/generations", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    out, _ := io.ReadAll(resp.Body)
    fmt.Println(string(out))
}

Authentication

Every call needs a Bearer token. Generate keys at reapi.ai/settings/apikeys.

Authorization: Bearer YOUR_API_KEY

Endpoint

POST /api/v1/videos/generations
GET  /api/v1/tasks/{id}

Submission is async. The POST returns immediately with a task_id; the task endpoint returns the same envelope until completion. Polling does not consume credits. Generation typically takes 1–5 minutes, longer for long clips.

Modes

There is no mode field — the model id is always wan3.0-video and the mode follows from which media fields you send:

Media families

Every media input belongs to one of two families, and the two cannot be mixed in one request:

A bare image_urls array is assigned as follows:

1. If generation_type is set, it decides (frame or reference).
2. Otherwise, if the request already carries reference media (video_urls, audio_urls, audio_url, file_url, link_url), the images are reference images.
3. Otherwise they are frame images: the first becomes first_frame, the second last_frame.

Use image_with_roles when you want explicit control.

Request body

Media limits

With reference video present, the total input video duration plus the output duration must stay within 30 seconds — including when duration is -1.

Content filter

Ordinary API keys always use the NSFW channel. Both content_filter and nsfw_checker are ignored, so sending true does not enable filtering.

Administrator-owned API keys can set content_filter to a boolean:

For administrator keys, the legacy boolean nsfw_checker remains accepted; content_filter takes precedence when both are present. Invalid non-boolean values are rejected. 2K and 4K with filtering enabled are rejected before credits are charged. The effective setting is preserved on every fallback, and the filter choice does not change the public price.

Administrator key permissions are cached for up to 5 minutes. Role changes may take that long to affect requests.

Playground generation is disabled. Use Authorization: Bearer YOUR_API_KEY; a website session cookie cannot submit this model, even for administrators.

Response envelope

Submit and poll share the same shape — only status and output fill in over time.

{
  "id": "task_018f5a3a1b6e7d9f8c2b4d6e8f0a2c4e",
  "model": "wan3.0-video",
  "status": "completed",
  "created_at": 1735000000,
  "output": {
    "video_urls": ["https://cdn.reapi.ai/media/tasks/.../0.mp4"]
  },
  "error": null
}

Poll GET /api/v1/tasks/{id} (see the Tasks reference) until status === "completed". output.video_urls holds the generated MP4 URL.

Pricing

Billed per billable second, scaled by resolution. The mode does not change the rate, and audio: true costs the same as audio: false.

billable_seconds = reference_video_seconds + duration
credits          = ceil(per_second_usd × billable_seconds × 1000)

where 1 credit = $0.001. Current per-second rates for each resolution tier are on the model page — that table is dynamic and always reflects the live rate. Failed jobs are refunded automatically.

Three things drive the bill more than anything else:

• Resolution. Omitting resolution generates and bills at 1080P. Pass 480P or 720P explicitly when cost matters.
• Reference video. Every clip in video_urls is processed as well as generated, so its own length is billable on top of duration. reAPI measures the clips server-side at submit time, and their combined length with duration is capped at 30 seconds. A 6-second reference clip with duration: 8 bills 14 seconds. Reference images, audio, documents and web pages carry no billable length — only video does. A clip reAPI cannot read is rejected rather than billed as zero.
• duration: -1. The model chooses the length, so the final second count is not knowable at submit time. reAPI charges the 30-second ceiling for these requests. Pass an explicit duration whenever you can.

Errors

Invalid combinations are rejected before any generation is billed.

Full catalog: Errors.

Tips

• Keep the frame family and the reference family apart. If you want a specific still to open the clip and a character carried across shots, the frame role wins — send the character as the first frame, not as a reference image.
• generation_type is worth setting explicitly whenever image_urls is present alongside any other media. The inference rules are well-defined, but a stated role is easier to reason about six months later.
• In reference mode, name the assets in the prompt (图1, 视频1, 音频1). Indices count within each media type, not across all of them.
• size only frames the output; with a first-frame image the source aspect ratio dominates the result.
• Long clips take proportionally longer. A 30-second 1080P request can sit well past the 5-minute mark — set your poll timeout accordingly.

Related

• Errors catalog
• Authentication
• Quickstart
• Wan 2.7 Video
• Wan 2.7 Image