Name: Wan 2.5 – Text-to-Video Generation | $0.07/call | API.market
Brand: magicapi
SKU: api-magicapi-text-to-video-generation-wan-video-wan-25-t2v
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 High-Quality Text-to-Video Generation API (Wan 2.5)

## Overview
The High-Quality Text-to-Video Generation API powered by the Alibaba Wan 2.5 model allows you to generate stunning videos from textual descriptions with exceptional accuracy and speed. This API transforms written content into engaging video formats seamlessly, making it ideal for various applications in Artificial Intelligence, Video, and Entertainment industries.

## Features
- **State-of-the-art AI Model**: Utilize the advanced capabilities of the Alibaba Wan 2.5 model for text-to-video conversion.
- **High-Resolution Video Output**: Supports multiple video resolutions including 1280x720 and 1920x1080.
- **Customizable**: Adjust video attributes such as duration, resolution, audio sync, and more.
- **Speed and Efficiency**: Fast processing times ensure quick turnaround for video generation.
- **Accurate and Engaging**: High fidelity in translating textual descriptions to video.

## Use Cases
1. **Marketing and Advertising**: Create promotional videos from product descriptions to engage customers more effectively.
2. **Educational Content**: Generate visual learning materials from text-based educational resources.
3. **Social Media Content**: Quickly produce captivating videos for social media platforms using written posts or descriptions.
4. **Entertainment**: Generate short movies or animated clips from scripts or story outlines.
5. **News Broadcasting**: Convert written news reports into video segments for quick dissemination.

## Visual Examples
### Example Input and Output
- **Input Prompt**: `70s broadcast news announcing that Wan 2.5 is now on API Market, as seen through a 70s TV set in a cosy 70s living room`

![Description of the output video](https://blog.api.market/wp-content/uploads/2026/02/wan2.5-output-api-market.mp4)

## Pricing
- **Pay As You Go (PAYG)**: Only pay for what you use.
- **Pricing Per Second**:
  - **480p**: $0.07 per second
  - **720p**: $0.14 per second
  - **1080p**: $0.21 per second
- **Free GET Requests**: Checking prediction status (`GET /api/v1/magicapi/text-to-video-generation-wan-video-wan-25-t2v/predictions/{id}`) does not count toward usage.
- **No Monthly Fees**: Simple per-second pricing with no subscription fees or minimum commitments.
## API Documentation

### Base URL
All API requests should be made to:
```
https://prod.api.market/api/v1/magicapi/text-to-video-generation-wan-video-wan-25-t2v
```

### Authentication
Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API uses asynchronous processing for predictions. The typical flow is:
1. **Submit a prediction request** to the POST endpoint.
2. **Receive a prediction ID** in the response.
3. **Poll the GET endpoint** with the prediction ID to check status.
4. **Continue polling** until the prediction is complete.

### Endpoints

#### Create a Prediction
Creates a new text-to-video prediction.

**Request**
```
POST /api/v1/magicapi/text-to-video-generation-wan-video-wan-25-t2v/predictions
```
**Request Body Example**
```json
{
  "version": "4e22e64c604706aa4ac1929a7ae146ea033f39bb228e896da79d91b7a39e8d32",
  "input": {
    "size": "1280*720",
    "prompt": "70s broadcast news announcing that Wan 2.5 is now on API Market, as seen through a 70s TV set in a cosy 70s living room",
    "duration": 10,
    "negative_prompt": "",
    "enable_prompt_expansion": true
  }
}
```
**Response Example**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "4e22e64c604706aa4ac1929a7ae146ea033f39bb228e896da79d91b7a39e8d32",
  "status": "starting",
  "created_at": "2026-02-02T07:28:24.562Z"
}
```

**cURL Example**
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-video-generation-wan-video-wan-25-t2v/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "4e22e64c604706aa4ac1929a7ae146ea033f39bb228e896da79d91b7a39e8d32",
    "input": {
      "size": "1280*720",
      "prompt": "70s broadcast news announcing that Wan 2.5 is now on API Market, as seen through a 70s TV set in a cosy 70s living room",
      "duration": 10,
      "negative_prompt": "",
      "enable_prompt_expansion": true
    }
  }'
```

#### Get Prediction Status and Results
Retrieve the status and results of a text-to-video prediction.

**Request**
```
GET /api/v1/magicapi/text-to-video-generation-wan-video-wan-25-t2v/predictions/{id}
```
**Response Example**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/02/wan2.5-output-api-market.mp4",
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```

**cURL Example**
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-video-generation-wan-video-wan-25-t2v/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## Status Codes
- **200 OK**: Request successful
- **201 Created**: Resource successfully created
- **400 Bad Request**: Invalid input parameters or malformed request
- **401 Unauthorized**: Missing or invalid API key
- **403 Forbidden**: Valid API key but insufficient permissions
- **404 Not Found**: Resource not found
- **429 Too Many Requests**: Rate limit exceeded
- **500 Internal Server Error**: Server-side error
- **503 Service Unavailable**: Service temporarily unavailable

## Rate Limits
Information about potential rate limits:
- Implement retry strategies for handling rate limits.
- Use best practices to handle rate limits efficiently.

## Error Handling
- **Interpreting Error Responses**: Error responses provide details about the issue.
- **Common Errors**:
    - "Invalid parameter": Ensure all required fields are provided.
    - "Unauthorized": Verify your API key.
- **Retry Strategies**: Implement exponential backoff for transient errors.

**Error Response Example**
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```

## Implementation Guide

### Example Code
**JavaScript Example**
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/${productInfo.slug}";

async function createAndWaitForPrediction(inputData) {
  try {
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({ version: "4e22e64c604706aa4ac1929a7ae146ea033f39bb228e896da79d91b7a39e8d32", input: inputData })
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    
    const prediction = await response.json();
    const predictionId = prediction.id;
    
    return await pollForResults(predictionId);
  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function pollForResults(predictionId) {
  const MAX_TIMEOUT = 600000; // 600 seconds (10 minutes)
  const POLL_INTERVAL = 1000; // 1 second between checks
  
  const startTime = Date.now();
  
  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

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

    const prediction = await response.json();

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

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

    await delay(POLL_INTERVAL);
  }

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

**Python Example**
```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/${productInfo.slug}"

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": "4e22e64c604706aa4ac1929a7ae146ea033f39bb228e896da79d91b7a39e8d32", "input": input_data}
    )

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

    prediction = response.json()
    prediction_id = prediction["id"]

    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second between checks

    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"] == "failed":
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")

        time.sleep(POLL_INTERVAL)

    raise Exception("Prediction timed out after 10 minutes")
```

**cURL Example**
```bash
# Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-video-generation-wan-video-wan-25-t2v/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "4e22e64c604706aa4ac1929a7ae146ea033f39bb228e896da79d91b7a39e8d32",
    "input": {
      "image": "https://example.com/image.jpg"
    }
  }'

# Check prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-video-generation-wan-video-wan-25-t2v/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- **Monitor Usage**: Regularly check your API usage and prediction processing times to optimize performance and costs.
- **Batch Process**: Group similar requests together to improve processing efficiency.

## FAQ
**What is the typical processing time for a prediction?**
Processing times vary based on complexity, but most predictions complete within a few minutes.

**How do I handle rate limits?**
Implement retry mechanisms and exponential backoff strategies to effectively handle rate limits.

**What should I do if a prediction fails?**
Refer to the error message in the response for details and adjust your request parameters accordingly.

## 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[at]api.market.

Generate cinematic-quality videos from text prompts using the Alibaba Wan 2.5 model. Supports 1080p HD output. From $0.07/call. Try it free on API.market.