Name: Wan 2.6 T2V API: Text to Video by Alibaba
Brand: magicapi
SKU: api-magicapi-text-to-video-generator-wan-video-wan-2-6-t2v
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Text-to-Video Generator API (Wan 2.6 T2V)

## Overview
Wan 2.6 T2V is a text-to-video model from Alibaba (Wan). You describe a scene in a text prompt and the model returns a video of 5, 10 or 15 seconds at 720p or 1080p, in landscape or portrait. You can also pass an audio file (wav or mp3, 3 to 30 seconds) for voice or music synchronization, a negative prompt, and a seed.

## Features
- **Text to video:** generate a video from a text `prompt`.
- **Four sizes:** `1280*720` (the default) and `720*1280` at 720p, `1920*1080` and `1080*1920` at 1080p, in landscape or portrait.
- **Three durations:** 5 (the default), 10 or 15 seconds with `duration`.
- **Audio input:** an optional `audio` file (wav/mp3, 3 to 30 seconds, up to 15MB) for voice or music synchronization.
- **Prompt expansion:** `enable_prompt_expansion` (default true) turns on the prompt optimizer.
- **Multi-shot segmentation:** `multi_shots` splits the video into several shots. It only works when `enable_prompt_expansion` is on.
- **Negative prompt and seed:** steer away from unwanted elements with `negative_prompt`, and reuse a `seed` for reproducible generation.

## Use Cases
- **Social media clips:** make short landscape or portrait videos from a written idea.
- **Ads and product teasers:** turn a script line into a short scene for a campaign draft.
- **Storyboards and previsualization:** test camera moves and scenes before a shoot.
- **Music and voice content:** generate a clip synchronized to your own audio track.

## Visual Examples
This is a real request sent through api.market and the file it returned.

Prompt used: "A drone shot glides over a turquoise lagoon toward a small palm-covered island at sunrise"

Other inputs: `size`: "1280*720", `duration`: 5 (all other fields at their defaults).

**Output video:** [Watch the example video](https://blog.api.market/wp-content/uploads/2026/10/wan-2.6-t2v-output-api-market.mp4)

## Pricing
- **Pay As You Go (PAYG) pricing:** you only pay for what you use.
- **Price:** $0.125 per API unit.
- **1 API unit** = 1 second of output video, rounded up to the next whole second.
- **`size` "1280*720" or "720*1280" (720p):** 1 unit per second, so $0.125 per second of output.
- **`size` "1920*1080" or "1080*1920" (1080p):** 1.5 units per second, so $0.1875 per second of output. The total is rounded up to a whole unit per request.
- **No size set:** the model default is `1280*720`, so it bills at 1 unit per second.
- **Worked example:** a 5 second video at `1280*720` is 5 units = $0.625. The same 5 second video at `1920*1080` is 5 x 1.5 = 7.5, rounded up to 8 units = $1.00. A 10 second video at 1080p is 15 units = $1.875, and a 15 second video at 1080p is 22.5, rounded up to 23 units = $2.875.
- **Failed or cancelled predictions** are not billed.
- **GET requests** to check prediction status (GET /api/v1/magicapi/text-to-video-generator-wan-video-wan-2-6-t2v/predictions/{id}) are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
`https://prod.api.market/api/v1/magicapi/text-to-video-generator-wan-video-wan-2-6-t2v`

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

### Asynchronous Processing
**IMPORTANT:** This API is asynchronous.
1. POST `/predictions` with the model `version` and your `input`.
2. The API returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`. 201 means the request was accepted; it is not an error.
3. Poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
4. When `status` is `succeeded`, `output` holds the URL of the generated video.
5. When `status` is `failed`, the `error` field explains why.

### Endpoints

#### Create a Prediction
`POST /predictions`

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-video-generator-wan-video-wan-2-6-t2v/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "e26da39f3adc03385c49adb156263148660557d28f3e26bcdb331b174a794077",
    "input": {
      "prompt": "A drone shot glides over a turquoise lagoon toward a small palm-covered island at sunrise",
      "size": "1280*720",
      "duration": 5
    }
  }'
```

Response (201 Created):
```json
{
  "id": "w3n8fz0q6sr2c0ct4m9yhkd1ve",
  "version": "e26da39f3adc03385c49adb156263148660557d28f3e26bcdb331b174a794077",
  "status": "starting",
  "created_at": "2026-10-13T11:04:27.118Z"
}
```

#### Check Prediction Status
`GET /predictions/{id}`

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-video-generator-wan-video-wan-2-6-t2v/predictions/w3n8fz0q6sr2c0ct4m9yhkd1ve" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response (200 OK) once the prediction has finished:
```json
{
  "id": "w3n8fz0q6sr2c0ct4m9yhkd1ve",
  "status": "succeeded",
  "input": {
    "prompt": "A drone shot glides over a turquoise lagoon toward a small palm-covered island at sunrise",
    "size": "1280*720",
    "duration": 5
  },
  "output": "https://blog.api.market/wp-content/uploads/2026/10/wan-2.6-t2v-output-api-market.mp4",
  "error": null,
  "created_at": "2026-10-13T11:04:27.118Z",
  "started_at": "2026-10-13T11:04:27.655Z",
  "completed_at": "2026-10-13T11:06:02.903Z"
}
```

### Input Parameters
| Parameter | Type | Required | Default | Allowed values | Description |
|---|---|---|---|---|---|
| `prompt` | string | Yes | none |  | Text prompt for video generation |
| `negative_prompt` | string | No | "" (empty) |  | Negative prompt to avoid certain elements |
| `audio` | string (URL) | No | none |  | Audio file (wav/mp3, 3-30s, ≤15MB) for voice/music synchronization |
| `size` | string | No | "1280*720" | `1280*720`, `720*1280`, `1920*1080`, `1080*1920` | Video resolution and aspect ratio |
| `duration` | integer | No | 5 | `5`, `10`, `15` | Duration of the generated video in seconds |
| `enable_prompt_expansion` | boolean | No | true |  | If set to true, the prompt optimizer will be enabled |
| `multi_shots` | boolean | No | false |  | Enable intelligent multi-shot segmentation (only active when enable_prompt_expansion is enabled). True enables multi-shot segmentation, false generates single-shot content. |
| `seed` | integer | No | none |  | Random seed for reproducible generation |

### Output
`output` is a single URL (string) pointing to the generated MP4 video.

## Status Codes
- **200 OK:** prediction status returned.
- **201 Created:** prediction accepted. Poll GET `/predictions/{id}` for the result.
- **400 Bad Request:** invalid or missing input fields.
- **401 Unauthorized:** missing or invalid API key.
- **404 Not Found:** unknown prediction ID.
- **429 Too Many Requests:** too many requests in a short time. Wait and retry.
- **500 Internal Server Error:** server-side error. Retry after a short wait.

## 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
- **Request errors (4xx):** check the response body, fix the input fields and send the request again.
- **Failed predictions:** when GET returns `status: "failed"`, read the `error` field. Failed predictions are not billed.
- **Rate limits (429) and server errors (5xx):** retry with exponential backoff.

## Implementation Guide

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

async function createPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "e26da39f3adc03385c49adb156263148660557d28f3e26bcdb331b174a794077", input })
  });
  if (response.status !== 201 && response.status !== 200) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }
  return response.json();
}

async function waitForPrediction(id, timeoutMs = 1200000, intervalMs = 5000) {
  const start = Date.now();
  while (Date.now() - start < timeoutMs) {
    const response = await fetch(`${baseUrl}/predictions/${id}`, {
      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 new Promise((resolve) => setTimeout(resolve, intervalMs));
  }
  throw new Error("Timed out waiting for the prediction");
}

const prediction = await createPrediction({
  "prompt": "A drone shot glides over a turquoise lagoon toward a small palm-covered island at sunrise",
  "size": "1280*720",
  "duration": 5
});
const output = await waitForPrediction(prediction.id);
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-wan-video-wan-2-6-t2v"

def create_prediction(input_data):
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers={"Content-Type": "application/json", "x-api-market-key": API_KEY},
        json={"version": "e26da39f3adc03385c49adb156263148660557d28f3e26bcdb331b174a794077", "input": input_data},
    )
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")
    return response.json()

def wait_for_prediction(prediction_id, timeout=1200, interval=5):
    start = time.time()
    while time.time() - start < timeout:
        response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers={"x-api-market-key": API_KEY},
        )
        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(interval)
    raise Exception("Timed out waiting for the prediction")

prediction = create_prediction({
  "prompt": "A drone shot glides over a turquoise lagoon toward a small palm-covered island at sunrise",
  "size": "1280*720",
  "duration": 5
})
print(wait_for_prediction(prediction["id"]))
```

### cURL
```bash
# Step 1: create the prediction (returns 201 Created with an id)
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-video-generator-wan-video-wan-2-6-t2v/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "e26da39f3adc03385c49adb156263148660557d28f3e26bcdb331b174a794077",
    "input": {
      "prompt": "A drone shot glides over a turquoise lagoon toward a small palm-covered island at sunrise",
      "size": "1280*720",
      "duration": 5
    }
  }'

# Step 2: poll with the returned id until status is succeeded, failed or canceled
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-video-generator-wan-video-wan-2-6-t2v/predictions/w3n8fz0q6sr2c0ct4m9yhkd1ve" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## FAQ
**Q: How long can the videos be?**  
A: `duration` accepts 5, 10 or 15 seconds. The default is 5. You are billed for the seconds of video the model returns.

**Q: Which sizes can I choose?**  
A: `1280*720`, `720*1280`, `1920*1080` and `1080*1920`. The 720p sizes cost 1 unit per second and the 1080p sizes cost 1.5 units per second.

**Q: What is the audio input for?**  
A: `audio` takes a wav or mp3 file (3 to 30 seconds, up to 15MB) for voice or music synchronization. It is optional.

**Q: When does multi_shots work?**  
A: Only when `enable_prompt_expansion` is true (the default). With `multi_shots` false the model generates single-shot content.

**Q: Is POST returning 201 an error?**  
A: No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.

## 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 5, 10 or 15 second videos at 720p or 1080p from text with Alibaba Wan 2.6 T2V. Billed per second of output, from $0.125 per second.