Name: Wan2.2 – Text to Video Generation | $0.07/call | API.market
Brand: magicapi
SKU: api-magicapi-text-to-video-generator-ultra-fast-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Ultra-Fast Text-to-Video Generator API (Wan2.2)

## Overview
The Ultra-Fast Text-to-Video Generator API (Wan2.2) empowers you to generate high-quality videos from text prompts in just seconds. It leverages lightning-fast, cost-effective, PrunaAI-optimized Wan 2.2 A14B technology for scalable video generation. Whether you’re creating promotional clips, educational videos, or social media content, this API delivers rapid results without compromising on quality.

## Features
- **Immediate Text-to-Video**: Instantly convert text prompts into realistic video outputs.  
- **Low Latency**: Optimized for minimal processing time, ensuring near-real-time video generation.  
- **Flexible Resolution & Aspect Ratio**: Choose between multiple resolutions and aspect ratios (e.g., 480p, 720p, 16:9, 9:16) to fit your project requirements.  
- **Seed Control**: Optionally set a random seed for reproducible video outputs, or leave blank for random.  
- **Safety Checker Toggle**: Disable the safety checker if desired, enabling advanced creative freedom (use responsibly).  
- **Scalable and Cost-Effective**: PrunaAI optimizations enable high performance at lower costs.

## Use Cases
1. **E-commerce Product Showcases**  
   Generate quick, engaging product demo videos from descriptive text – perfect for highlighting retail items in different settings.

2. **Social Media Marketing**  
   Quickly produce dynamic content for social media campaigns. Grab audience attention with video ads or short teasers based on simple text prompts.

3. **Educational Videos**  
   Create short instructional clips or explainer videos from text-based lesson plans without needing an entire video production team.

4. **Entertainment & Trailers**  
   Spin up cinematic previews or concept teasers for movies, games, or creative projects, accelerating production timelines.

5. **Training & Simulation**  
   Generate scenario-based training videos from text prompts. Ideal for corporate training modules or educational simulations.

## Visual Examples

### Example Video Generation
Prompt (input):  
"A sports car is driving very fast along a beach at sunset"

When the prediction succeeds, you’ll get an output video URL. Below is an example output showcasing the generated clip:

![Sample output video for "A sports car is driving very fast along a beach at sunset"](https://replicate.delivery/xezq/PNTe7b9VBLxFPKB35GDhzrMYaph7WKspkexwtxeRPxJqfuXUB/output.mp4)

(This video link may be a placeholder; replace with the actual output URL from your own prediction.)

## Pricing
- Pay As You Go (PAYG) – pay only for the videos you generate.  
- 1 API unit = 1 video processed.  
- 480p costs $0.07 for 5 seconds /1 API unit
- 720p costs $0.14 for 5 seconds / 2 API units
- GET requests to retrieve the prediction status (GET /api/v1/magicapi/text-to-video-generator-ultra-fast-api/predictions/{id}) are free.  
- No monthly subscription fees or usage limits – simple per-call pricing.

## API Documentation

### Base URL
All requests should be sent to:
```
https://prod.api.market/api/v1/magicapi/text-to-video-generator-ultra-fast-api
```

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

### Asynchronous Processing
This API runs predictions asynchronously. After creating a prediction, you receive a prediction ID. Use the ID to poll the status endpoint until the process is complete.

Typical flow:
1. POST /api/v1/magicapi/text-to-video-generator-ultra-fast-api/predictions  
2. Receive a prediction ID in the response  
3. GET /api/v1/magicapi/text-to-video-generator-ultra-fast-api/predictions/{id}  
4. Continue checking status until the prediction completes (status is “succeeded” or “failed”)  

Implementation guidelines:
- Poll status every 1 second.  
- Maximum timeout: 600 seconds (10 minutes).  
- Manage “starting” and “processing” statuses by continuing to poll until completion.  
- Handle “failed” status or timeouts with appropriate error handling.

### Endpoints

#### 1. Create a Prediction
• **Method**: POST  
• **Endpoint**:  
  /api/v1/magicapi/text-to-video-generator-ultra-fast-api/predictions  

Creates a new video generation task. The response includes a prediction ID you can use to check status.

Example Request (cURL):
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-video-generator-ultra-fast-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
      "version": "1adb67211e01b96e48f9ab2bc5da80cac6f07604f2117ffafa729808850ffc0e",
      "input": {
          "prompt": "A sports car is driving very fast along a beach at sunset",
          "go_fast": true,
          "num_frames": 81,
          "resolution": "480p",
          "aspect_ratio": "16:9",
          "sample_shift": 12,
          "frames_per_second": 16
      }
  }'
```

Example Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "1adb67211e01b96e48f9ab2bc5da80cac6f07604f2117ffafa729808850ffc0e",
  "status": "starting",
  "created_at": "2025-08-17T17:05:15.042Z"
}
```

#### 2. Get Prediction Status
• **Method**: GET  
• **Endpoint**:  
  /api/v1/magicapi/text-to-video-generator-ultra-fast-api/predictions/{id}  

Retrieves the status and output of the prediction indicated by {id}.

Example Request (cURL):
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-video-generator-ultra-fast-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Example Response (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://example.com/output.mp4",
  "created_at": "2025-08-17T17:05:15.042Z",
  "started_at": "2025-08-17T17:05:20.000Z",
  "completed_at": "2025-08-17T17:06:10.000Z"
}
```

## Status Codes
- **200 OK**: Request succeeded.  
- **201 Created**: Resource (prediction) created successfully.  
- **400 Bad Request**: Invalid input or malformed request.  
- **401 Unauthorized**: Missing or invalid API key.  
- **403 Forbidden**: The API key is valid, but the request lacks necessary permissions.  
- **404 Not Found**: Prediction ID not found.  
- **429 Too Many Requests**: Rate limit exceeded; try again later.  
- **500 Internal Server Error**: Server encountered an error; retry later.  
- **503 Service Unavailable**: Service is temporarily unavailable or under maintenance.

## Rate Limits
API usage may be subject to rate limits. If you receive a 429 Too Many Requests error, reduce your request frequency. Implement exponential backoff or similar retry strategies.

## Error Handling
When an error occurs, the API returns a JSON response detailing the issue. For instance:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```

- **invalid_parameter**: Check that all required fields are provided.  
- **authentication_error**: Ensure the API key is correct.  
- **rate_limit_exceeded**: Wait and retry after some delay.  

## Implementation Guide

### Example Code

#### JavaScript (with async/await)
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/text-to-video-generator-ultra-fast-api";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({
        version: "1adb67211e01b96e48f9ab2bc5da80cac6f07604f2117ffafa729808850ffc0e",
        input: inputData
      })
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    
    const prediction = await response.json();
    const predictionId = prediction.id;
    
    // Step 2: Poll for results with timeout
    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

  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
```python
# Python example with proper polling and timeout
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/text-to-video-generator-ultra-fast-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    payload = {
        "version": "1adb67211e01b96e48f9ab2bc5da80cac6f07604f2117ffafa729808850ffc0e",
        "input": input_data
    }
    
    response = requests.post(f"{BASE_URL}/predictions", json=payload, headers=headers)
    
    if response.status_code not in [200, 201]:
        raise Exception(f"API error: {response.status_code} {response.text}")
    
    prediction = response.json()
    prediction_id = prediction["id"]
    
    # Step 2: Poll for results with timeout
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second
    start_time = time.time()
    
    while time.time() - start_time < MAX_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"] == "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
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/text-to-video-generator-ultra-fast-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
      "version": "1adb67211e01b96e48f9ab2bc5da80cac6f07604f2117ffafa729808850ffc0e",
      "input": {
        "prompt": "A bustling city street at night",
        "frames_per_second": 16,
        "num_frames": 81
      }
    }'

# Response example:
# { "id": "abcd1234", "status": "starting" }

# Step 2: Check status by ID
curl -X GET "https://prod.api.market/api/v1/magicapi/text-to-video-generator-ultra-fast-api/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Keep polling until status is "succeeded" or "failed".
```

### Performance Optimization
- **Optimize Prompt Length**: Efficient, concise prompts can speed up rendering and reduce costs.  
- **Resolution & Frames**: Lower resolution or fewer frames can reduce processing time, but might affect final video quality. Find the right balance for your project.  
- **Batch Requests**: Minimize repeated idle calls by strategically scheduling or batching tasks.

## FAQ
1. **How long does a typical prediction take?**  
   Most predictions complete within a few seconds, but it can take longer depending on the requested frames, resolution, and other parameters.

2. **Are GET status checks free?**  
   Yes, GET requests to /predictions/{id} are free and do not consume your API units.

3. **How do I handle timeouts?**  
   Implement a maximum waiting period of 10 minutes. If status remains “starting” or “processing” beyond that, abort and handle the error gracefully.

4. **Is there a limit on the length of generated videos?**  
   The default maximum frames supported is 121 frames, with recommended 81 frames for optimal performance. Higher frames might be supported but could adversely affect processing times.

5. **Can I disable safety checks?**  
   Yes, you can set “disable_safety_checker” to true in the input payload. Use responsibly.

## 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 high-quality AI videos from text prompts in seconds. Supports 480p and 720p resolutions. From $0.07/call. Try it free on API.market.

Wan2.2 – Text to Video Generation | $0.07/call | API.market