Name: Wan2.2 – AI Video & Image Generation | $0.02/call | API.market
Brand: magicapi
SKU: api-magicapi-ultra-fast-text-to-image-image-to-video-api
Availability: InStock
Rating: 5.00 (1 reviews)
Author: API Market

Shashank Agarwal

# ⚡ Ultra-Fast Text-to-Video & Image-to-Video API (Wan2.2)

## Overview
This API enables developers to transform text or images into vivid AI-generated images or dynamic videos within seconds. Powered by a 5B-parameter model, Wan2.2 accelerates creativity by enabling near-instantaneous visual generation based on custom prompts or input images.

By leveraging this API, you can:
- Generate stunning videos from textual prompts.
- Create vivid images with precise control using seed, resolution, and aspect ratio options.
- Produce rapid outputs, even with high frame rates and multiple frames.

## Features
- Text-to-Image Generation: Provide a descriptive prompt, and the API produces a fully realized image.  
- Image-to-Video Transformation: Supply an input image, and the API morphs it into a video sequence matching your desired narrative.  
- Adjustable Resolution & Aspect Ratio: Generate outputs in either 16:9 or 9:16 format, at 480p or 720p.  
- Control Over Frames & Speed: Define frame rates, number of frames, and enable high-speed generation.  
- Asynchronous Processing: Submit requests and poll for results, enabling parallel tasks.

## Use Cases
1. E-commerce Product Showcases  
   • Generate quick promotional videos from existing product images and short promotional copy.  
   • Showcase products in various scenarios (e.g., “A shoe model walking on a stylish runway”).  

2. Film Pre-Visualization  
   • Convert storyboards or concept art into animated samples for quick preview of cinematic sequences.  
   • Ideal for directors, storyboard artists, and VFX teams wanting near-instant previews.  

3. Social Media Content Generation  
   • Create short, attention-grabbing video snippets for ads or posts from textual prompts or static images.  
   • Perfect for marketing agencies and content creators.  

4. Education & Training Videos  
   • Illustrate educational concepts (e.g., “Layers of the Earth shifting in motion”) in dynamic, explorable videos.  
   • Helpful for teachers, trainers, and online course creators.  

5. Gaming & VR Prototyping  
   • Quickly generate visual assets for conceptualizing new VR worlds or gaming environments using textual descriptions.  
   • Useful for game developers, 3D artists, or indie studios needing rapid iteration.

## Visual Examples

Below is an example of an input image URL and a corresponding generated output video. The prompt used was:  
“a car is driving at speed along a runway, it leaves us in the dust”

### Example Input Image
![Example input image showing a car on a runway](https://replicate.delivery/pbxt/NUHxZDgAgbYuAihJY7P9LBb7Qjcqxf5VHxRMErQAYmW5S27r/image.png)

### Example Output Video
![Example output video showing a generated scene of a car driving fast along a runway](https://replicate.delivery/xezq/kItohszexaWdcCLlH9TBLXNVZb6dnmovyRuCXlrXFVfu8NIVA/output.mp4)

Observe how the input image was transformed into a dynamic, AI-generated video representing the prompt.

## Pricing
- Pay As You Go (PAYG) – Only pay for what you use.  
- 480 costs $0.02 per video (1 API Unit)
- 720 costs $0.04 per video (2 API Units)
- GET requests (to check prediction status) are free and do not count toward API unit usage.  
- No monthly subscription fees or usage limits – simple per-call pricing.

## API Documentation

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

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

### Asynchronous Processing
This API processes predictions asynchronously. To use the service:

1. Send a POST request to create a prediction.  
2. Receive a prediction ID in the response.  
3. Poll the GET endpoint using the ID to check the status.  
4. When the prediction is complete (status = "succeeded"), you can retrieve the output.  

Implement the following best practices:
- Poll the prediction status at 1-second intervals.  
- Set a maximum timeout of 600 seconds (10 minutes).  
- Stop polling if status becomes "succeeded" or "failed," or if the timeout is reached.

### Endpoints

#### 1. Create a Prediction
POST /api/v1/magicapi/ultra-fast-text-to-image-image-to-video-api/predictions

• Description: Submits a new prediction request.  
• Request Body Parameters (JSON):  
  - version (string, default: c92ab4265c9b3b5ea9ac9a87df839ebfd662ee3a820d62c21305bf6501a73fe1)  
  - input (object):  
    - prompt (string, required): Descriptive text for the generation.  
    - image (string, optional): URL to an input image.  
    - num_frames, frames_per_second, resolution, aspect_ratio, etc.  

• Example Request (cURL):
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ultra-fast-text-to-image-image-to-video-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "image": "https://example.com/image.jpg",
      "prompt": "a car is driving at speed along a runway, it leaves us in the dust",
      "num_frames": 81,
      "resolution": "720p",
      "aspect_ratio": "16:9",
      "frames_per_second": 24
    }
  }'
```

• Example Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "c92ab4265c9b3b5ea9ac9a87df839ebfd662ee3a820d62c21305bf6501a73fe1",
  "status": "starting",
  "created_at": "2025-08-17T17:19:37.839Z"
}
```

#### 2. Get Prediction Status and Results
GET /api/v1/magicapi/ultra-fast-text-to-image-image-to-video-api/predictions/{id}

• Description: Returns prediction details, including status and output if the process is complete.  
• Path Parameter: id (string) – the unique prediction ID from the create step.  
• Example Request (cURL):
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-text-to-image-image-to-video-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

• Example Response (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://somewhere.delivery/path/to/output.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"
}
```

### Status Codes
- 200 OK: Request is successful.  
- 201 Created: A new prediction was created successfully.  
- 400 Bad Request: Invalid or missing parameters in the request.  
- 401 Unauthorized: API key is missing or invalid.  
- 403 Forbidden: Authenticated but not allowed to access this resource.  
- 404 Not Found: Prediction or resource not found.  
- 429 Too Many Requests: Rate limit has been exceeded; wait before retrying.  
- 500 Internal Server Error: A backend error occurred; retry or contact support.  
- 503 Service Unavailable: The service is temporarily lacking availability.

### Rate Limits
Currently, the API enforces a rate limit to protect from excessive usage. If you exceed these limits, you will receive a 429 Too Many Requests error. Implement retry strategies with exponential backoff to handle these responses.

### Error Handling
When an error occurs, the API typically returns a JSON response with details:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```
To handle errors:
- Check the status code and interpret the error message.  
- Correct any invalid parameters and retry if appropriate.  
- For transient issues like rate limits (429) or server errors (5xx), use a retry with backoff.

## Implementation Guide

Below are example implementations to create a prediction and wait for results. Adjust them to your needs and programming style.

### JavaScript (Node.js) Example
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ultra-fast-text-to-image-image-to-video-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({ 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 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/ultra-fast-text-to-image-image-to-video-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
    }
    response = requests.post(
        f"{BASE_URL}/predictions", headers=headers, json={"input": input_data}
    )
    if response.status_code != 200 and response.status_code != 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 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
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ultra-fast-text-to-image-image-to-video-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "image": "https://example.com/image.jpg"
    }
  }'

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

# Step 2: Poll for the prediction (replace abcd1234 with the actual prediction ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-text-to-image-image-to-video-api/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Repeat the GET request until "status" is "succeeded" or "failed".
```

### Performance Optimization
- Minimize large inputs and use compressed images wherever possible.  
- Use the “go_fast” flag for faster generation (default is true).  
- Carefully tune frame rates and number of frames to reduce processing time and costs.  

## FAQ
1. How long does it take to process a video?  
   • Most requests complete in a few seconds, but times can vary based on the requested resolution and number of frames.  

2. How do I handle large or slow requests?  
   • Implement the asynchronous polling flow with a 10-minute timeout and check status periodically.  

3. Can I generate purely from text without an image?  
   • Yes, simply omit the “image” field in the request and provide a prompt describing what you want to generate.  

4. Can I generate images instead of videos?  
   • Yes, if you only request a single frame (e.g., num_frames=1) or if you specify parameters to produce a single image.  

5. Where can I view usage or pricing details?  
   • Visit your API.market account dashboard to see usage and billing details in real-time.

## 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 AI videos and images from text or image prompts. Powered by a 5B-param model. From $0.02/call. Try it free on API.market.

Wan2.2 – AI Video & Image Generation | $0.02/call | API.market

⚡ Ultra-Fast Text-to-Image & Image-to-Video API (Wan2.2)

PAYG

MagicAPI

super quick and easy to use, makes both images and videos from text or pics in seconds. perfect for ads, social posts, or creative projects.
