Name: Wan 3.0 Prime Text-to-Video API
Brand: magicapi
SKU: api-magicapi-text-to-video-generator-alibaba-wan-3-prime
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Text-to-Video and Image-to-Video API (Wan 3.0 Prime)

## Overview
Wan 3.0 Prime is a video generation model from Alibaba. It turns a text `prompt` into a video, or animates an optional first-frame `image` guided by the prompt. Its developer describes it as producing videos up to 1080p and 30 seconds long.

Choose the output `resolution` (`480p`, `720p` or `1080p`), the `duration` (2 to 30 seconds) and the `aspect_ratio`. Each request returns the URL of one MP4 video.

## Features
- **Text to video**: describe the scene, subject, motion and camera in `prompt`.
- **Image to video**: pass a first-frame `image` (jpg, png, bmp or webp, up to 10 MB) and the model animates it, guided by the prompt.
- **Three resolutions**: `480p`, `720p` and `1080p` (default). The price per second depends on the resolution.
- **Duration from 2 to 30 seconds**: set `duration` in whole seconds (default `5`).
- **Aspect ratios**: `adaptive` (default, the model picks a ratio for the prompt), `16:9`, `9:16`, `1:1`, `4:3`, `3:4`. Ignored when an `image` is provided; the image's aspect ratio is used instead.
- **Prompt expansion**: `enable_prompt_expansion` (default `true`) expands and optimizes the prompt. It helps short prompts but adds latency. Set it to `false` to use your prompt as written.
- **Negative prompt**: describe content that should not appear with `negative_prompt`.
- **Seed**: set a seed (0 to 2147483647) to reproduce a result.

## Use Cases
1. **Social and marketing clips**: short vertical (`9:16`) or widescreen (`16:9`) videos from a text description.
2. **Animating still images**: bring a product photo, illustration or scene to life by sending it as `image`.
3. **Storyboards and previews**: quick 480p drafts of a shot before rendering the final version at 1080p.
4. **Longer single shots**: scenes of up to 30 seconds from one prompt.

## Visual Examples
### Example Input
Prompt: "A golden retriever puppy bounds across a sunlit backyard lawn chasing shimmering soap bubbles, filmed in slow motion with a shallow depth of field and warm late-afternoon light."

`resolution`: `480p`, `aspect_ratio`: `16:9`. All other fields were left at their defaults (`duration` `5`, no input image).

### Example Output
[Watch the example output](https://blog.api.market/wp-content/uploads/2026/10/wan-3-prime-output-api-market.mp4)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text prompt for video generation |
| `image` | string (URL) | No | none |  | Optional first-frame image to animate into a video (jpg, png, bmp or webp, up to 10 MB). When provided, the video is generated from this image guided by the prompt |
| `negative_prompt` | string | No | `""` |  | Describes content that should not appear in the video |
| `resolution` | string | No | `1080p` | `480p`, `720p`, `1080p` | Output video resolution |
| `aspect_ratio` | string | No | `adaptive` | `adaptive`, `16:9`, `9:16`, `1:1`, `4:3`, `3:4` | Aspect ratio of the generated video. `adaptive` lets the model choose the best ratio for the prompt. Ignored when an image is provided (the input image's aspect ratio is used) |
| `duration` | integer | No | `5` | 2 to 30 | Duration of the generated video in seconds |
| `enable_prompt_expansion` | boolean | No | `true` |  | Automatically expand and optimize the prompt. Improves quality for short prompts but increases latency |
| `seed` | integer | No | none |  | Random seed for reproducible generation. Range: 0-2147483647 |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.085 per API unit.
- **Billing unit**: 1 API unit = 1 second of output video at 480p. The output length is rounded up to a whole second and multiplied by the resolution factor:

| `resolution` | Factor | Price per second of video |
| --- | --- | --- |
| `480p` | 1 | $0.085 |
| `720p` | 2.059 | $0.175 |
| `1080p` (default, also used when `resolution` is omitted) | 4.118 | $0.35 |

- Billed on the length of the output video, which follows the requested `duration`.
- The example on this page (5 seconds at 480p) costs 5 x $0.085 = $0.425. A default request (5 seconds at 1080p) costs about $1.75. The longest video (30 seconds at 1080p) costs about $10.50.
- Text-to-video and image-to-video requests are billed the same way.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/text-to-video-generator-alibaba-wan-3-prime`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

Video generation takes longer than image generation. A polling interval of 5 seconds and an overall timeout of 1200 seconds (20 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-video-generator-alibaba-wan-3-prime/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "e92fcde3c44470e5965593dc39606c1b71d42d571c157748da351f1ff10efa49",
    "input": {
      "prompt": "A golden retriever puppy bounds across a sunlit backyard lawn chasing shimmering soap bubbles, filmed in slow motion with a shallow depth of field and warm late-afternoon light.",
      "resolution": "480p",
      "aspect_ratio": "16:9"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "qnydvc4pyhrmt0d17g2t859kgw",
  "version": "e92fcde3c44470e5965593dc39606c1b71d42d571c157748da351f1ff10efa49",
  "status": "starting",
  "created_at": "2026-10-14T20:06:01.827Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-video-generator-alibaba-wan-3-prime/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "qnydvc4pyhrmt0d17g2t859kgw",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/wan-3-prime-output-api-market.mp4",
  "error": null,
  "created_at": "2026-10-14T20:06:01.827Z",
  "started_at": "2026-10-14T20:06:02.827Z",
  "completed_at": "2026-10-14T20:07:30.827Z"
}
```

`output` is a single URL string pointing to the generated MP4 video.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `prompt`, a `duration` outside 2 to 30, or a `resolution` that is not in the list.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits

All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/text-to-video-generator-alibaba-wan-3-prime";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "e92fcde3c44470e5965593dc39606c1b71d42d571c157748da351f1ff10efa49", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 1200000;
  const pollInterval = 5000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 20 minutes");
}

createAndWaitForPrediction({
  "prompt": "A golden retriever puppy bounds across a sunlit backyard lawn chasing shimmering soap bubbles, filmed in slow motion with a shallow depth of field and warm late-afternoon light.",
  "resolution": "480p",
  "aspect_ratio": "16:9"
}).then((output) => console.log(output));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/text-to-video-generator-alibaba-wan-3-prime"

def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "e92fcde3c44470e5965593dc39606c1b71d42d571c157748da351f1ff10efa49", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])

def poll_for_results(prediction_id):
    max_timeout = 1200
    poll_interval = 5
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 20 minutes")

print(create_and_wait_for_prediction({
    "prompt": "A golden retriever puppy bounds across a sunlit backyard lawn chasing shimmering soap bubbles, filmed in slow motion with a shallow depth of field and warm late-afternoon light.",
    "resolution": "480p",
    "aspect_ratio": "16:9"
}))
```

## FAQ
- **Why is a request without `resolution` so much more expensive?**
  - The default `resolution` is `1080p`, which is billed at 4.118 units per second ($0.35 per second). Set `resolution` to `480p` ($0.085 per second) or `720p` ($0.175 per second) to pay less.
- **Can I animate my own image?**
  - Yes. Pass a public URL to a jpg, png, bmp or webp image (up to 10 MB) as `image` and describe the motion in `prompt`. The video uses the image's aspect ratio, so `aspect_ratio` is ignored.
- **How long can a video be?**
  - `duration` accepts whole seconds from 2 to 30. The default is 5 seconds.
- **Why does my video differ from my exact prompt?**
  - `enable_prompt_expansion` is `true` by default and rewrites the prompt before generation. Set it to `false` to turn this off.
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Generate videos from text or animate an image with Alibaba Wan 3.0 Prime, 2 to 30 seconds at up to 1080p. From $0.085 per second at 480p, pay as you go.