Name: Fast Image-to-Video API - Wan 2.2 A14B
Brand: magicapi
SKU: api-magicapi-fast-image-to-video-api-wan-video-wan-2-2-i2v-fast
Availability: InStock
Author: API Market

Shashank Agarwal

# 🚀 Fast Image-to-Video API (Wan 2.2 A14B)

## Overview
This API animates a still image into a short video guided by a text prompt. It runs Wan 2.2 A14B image-to-video in a version optimized by Pruna AI to be very fast and cheap. You send a starting image (`image`) and a `prompt` that describes the motion, and you get back a URL to the generated video. You can also pass an optional `last_image` to condition the end of the clip.

## Features
- **Image plus prompt to video**: `image` and `prompt` are the only required fields.
- **Optional last frame**: `last_image` conditions the generation on an ending image as well.
- **Two resolutions**: `480p` (default) or `720p`. At 480p, 16:9 corresponds to 832x480 px and 9:16 to 480x832 px.
- **Frame and frame-rate control**: `num_frames` from 81 to 121 (default 81, which the model notes gives the best results) and `frames_per_second` from 5 to 30 (default 16). With the defaults, 81 frames at 16 fps is about 5 seconds of video.
- **Optional interpolation**: set `interpolate_output` to `true` to interpolate the generated video to 30 FPS.
- **Custom LoRAs**: load `.safetensors` LoRA weights from a URL with `lora_weights_transformer` (HIGH transformer) and `lora_weights_transformer_2` (LOW transformer), and set their strength with `lora_scale_transformer` and `lora_scale_transformer_2`.
- **Tuning**: `seed` for repeatable results, `sample_shift` (1 to 20, default 12) and `go_fast` (default `true`).

## Use Cases
1. **Product and marketing clips**: Add motion to a product photo or campaign image for social posts and ads.
2. **Social media content**: Turn a portrait or scene photo into a short animated clip.
3. **Storyboards and previews**: Animate concept art or key frames to preview camera moves and motion.
4. **Animated artwork**: Bring illustrations and digital art to life, optionally with your own LoRA for a specific style or character.

## Visual Examples
### Example Input
![Input image used for the example](https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp)

**Prompt:**
`The woman turns her head toward the camera and smiles as rain keeps falling, the neon sign flickers softly`

All other fields were left at their defaults.

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

## Pricing
- **Pay As You Go (PAYG)**: you only pay for what you use.
- **Price**: $0.005 per API unit.
- **Billing unit**: each output video is billed a whole number of API units, depending on `resolution` and `interpolate_output`:
  - **480p** (default), `interpolate_output` false: 13 units = **$0.065 per video**
  - **480p**, `interpolate_output` true: 17 units = **$0.085 per video**
  - **720p**, `interpolate_output` false: 28 units = **$0.14 per video**
  - **720p**, `interpolate_output` true: 37 units = **$0.185 per video**
- A request that leaves both fields at their defaults is billed as 480p without interpolation ($0.065). The example on this page cost $0.065.
- 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 should be made to:
`https://prod.api.market/api/v1/magicapi/fast-image-to-video-api-wan-video-wan-2-2-i2v-fast`

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

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. Follow these steps:
1. Send a POST request to `/predictions` with the `version` and your `input`.
2. The API answers **201 Created** with a prediction `id` and a `status` of `starting` or `processing`. A 201 response means the job was accepted; it is not an error.
3. Poll GET `/predictions/{id}` with that ID.
4. Stop when `status` is `succeeded`, `failed` or `canceled`. On `succeeded`, `output` holds the URL of the generated video.

Video generation is not instant. The code samples below poll once per second and give up after 600 seconds (10 minutes); raise the timeout if your requests take longer.

### Endpoints

#### POST /api/v1/magicapi/fast-image-to-video-api-wan-video-wan-2-2-i2v-fast/predictions
Create a prediction. This is the request used for the example on this page:

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-image-to-video-api-wan-video-wan-2-2-i2v-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "4eaf2b01d3bf70d8a2e00b219efeb7cb415855ad18b7dacdc4cae664a73a6eea",
    "input": {
      "prompt": "The woman turns her head toward the camera and smiles as rain keeps falling, the neon sign flickers softly",
      "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "4eaf2b01d3bf70d8a2e00b219efeb7cb415855ad18b7dacdc4cae664a73a6eea",
  "status": "starting",
  "created_at": "2026-10-11T19:15:11.521Z"
}
```

#### GET /api/v1/magicapi/fast-image-to-video-api-wan-video-wan-2-2-i2v-fast/predictions/{id}
Check the status of a prediction and get its output. Status checks are free.

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-image-to-video-api-wan-video-wan-2-2-i2v-fast/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "4eaf2b01d3bf70d8a2e00b219efeb7cb415855ad18b7dacdc4cae664a73a6eea",
  "status": "succeeded",
  "input": {
    "prompt": "The woman turns her head toward the camera and smiles as rain keeps falling, the neon sign flickers softly",
    "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
  },
  "output": "https://blog.api.market/wp-content/uploads/2026/10/wan-2.2-i2v-fast-output-api-market.mp4",
  "error": null,
  "created_at": "2026-10-11T19:15:11.521Z",
  "started_at": "2026-10-11T19:15:12.104Z",
  "completed_at": "2026-10-11T19:16:20.733Z"
}
```

### Input Parameters
| Parameter | Type | Default | Required | Description |
|---|---|---|---|---|
| `prompt` | string | - | yes | Prompt for video generation. |
| `image` | string | - | yes | Input image to generate video from. |
| `last_image` | string | - | no | Optional last image to condition the video generation. If provided, creates smoother transitions between frames. |
| `num_frames` | integer | `81` | no | Number of video frames. 81 frames give the best results. Range: 81 to 121. |
| `resolution` | string | `480p` | no | Resolution of video. 16:9 corresponds to 832x480px, and 9:16 is 480x832px. One of: `480p`, `720p`. |
| `frames_per_second` | integer | `16` | no | Frames per second of the generated video. Range: 5 to 30. |
| `interpolate_output` | boolean | `false` | no | Interpolate the generated video to 30 FPS using ffmpeg. |
| `go_fast` | boolean | `true` | no | Go fast. |
| `sample_shift` | number | `12` | no | Sample shift factor. Range: 1 to 20. |
| `seed` | integer | - | no | Random seed. Leave blank for random. |
| `disable_safety_checker` | boolean | `false` | no | Disable safety checker for generated video. |
| `lora_weights_transformer` | string | - | no | Load LoRA weights for the HIGH transformer. Takes a URL to a .safetensors file. |
| `lora_scale_transformer` | number | `1` | no | Determines how strongly the transformer LoRA should be applied. |
| `lora_weights_transformer_2` | string | - | no | Load LoRA weights for the LOW transformer_2. Takes a URL to a .safetensors file and can be different from the transformer LoRA. |
| `lora_scale_transformer_2` | number | `1` | no | Determines how strongly the transformer_2 LoRA should be applied. |

### Status Codes
- **201 Created**: The POST request was accepted and the prediction was created (success). Poll the GET endpoint for the result.
- **200 OK**: The GET request succeeded. Check the `status` field to see whether the prediction has finished.
- **400 Bad Request**: Invalid input parameters or malformed request
- **401 Unauthorized**: Missing or invalid API key
- **404 Not Found**: Prediction not found
- **429 Too Many Requests**: Rate limit exceeded
- **500 Internal Server Error**: Server-side error

### Error Handling
1. **HTTP errors**: Read the response body for the error message. Fix the request for `400` and `401`; retry `429` and `5xx` with exponential backoff.
2. **Failed predictions**: If GET returns `status: "failed"`, the `error` field explains why. Failed and cancelled predictions are not billed.
3. **Timeouts**: If a prediction is still `starting` or `processing` when your timeout runs out, you can keep polling the same ID 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.

## Implementation Guide
### Example Code
#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/fast-image-to-video-api-wan-video-wan-2-2-i2v-fast";

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

  // 201 Created means the prediction was accepted
  if (!response.ok) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

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

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} ${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(POLL_INTERVAL);
  }

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

createAndWaitForPrediction({
  "prompt": "The woman turns her head toward the camera and smiles as rain keeps falling, the neon sign flickers softly",
  "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
}).then(output => console.log(output));
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/fast-image-to-video-api-wan-video-wan-2-2-i2v-fast"

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

    # 201 Created means the prediction was accepted
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")

    prediction = response.json()
    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"] in ("failed", "canceled"):
            error_msg = prediction.get("error") or "Unknown error"
            raise Exception(f"Prediction {prediction['status']}: {error_msg}")

        time.sleep(POLL_INTERVAL)

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

output = create_and_wait_for_prediction({
  "prompt": "The woman turns her head toward the camera and smiles as rain keeps falling, the neon sign flickers softly",
  "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
})
print(output)
```

#### cURL
```bash
# Step 1: Create a prediction (returns 201 Created)
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-image-to-video-api-wan-video-wan-2-2-i2v-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "4eaf2b01d3bf70d8a2e00b219efeb7cb415855ad18b7dacdc4cae664a73a6eea",
    "input": {
      "prompt": "The woman turns her head toward the camera and smiles as rain keeps falling, the neon sign flickers softly",
      "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp"
    }
  }'

# The response contains a prediction ID, for example:
# {"id": "ufawqhfynnddngldkgtslldrkq", "status": "starting", ...}

# Step 2: Check the prediction status (replace the ID with yours)
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-image-to-video-api-wan-video-wan-2-2-i2v-fast/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Repeat step 2 until status is "succeeded", "failed" or "canceled"
```

### Performance Optimization
- Use `480p` and leave `interpolate_output` off for the lowest price per video.
- Keep `num_frames` at 81 unless you need a longer clip; the model notes 81 frames give the best results.
- Use a fixed `seed` when you want to compare prompt changes on the same image.

## FAQ
1. **What do I need to send?**
   - A `prompt` and an `image` URL. Every other field is optional.

2. **How long is the output video?**
   - Length is `num_frames` divided by `frames_per_second`. With the defaults (81 frames at 16 fps) that is about 5 seconds.

3. **Can I use my own LoRA weights?**
   - Yes. Pass a `.safetensors` URL in `lora_weights_transformer` and/or `lora_weights_transformer_2`, and adjust `lora_scale_transformer` and `lora_scale_transformer_2` to control how strongly they are applied.

4. **What does a request cost?**
   - It depends on `resolution` and `interpolate_output`: $0.065 (480p), $0.085 (480p interpolated), $0.14 (720p) or $0.185 (720p interpolated) per video.

5. **How do I handle failures?**
   - Check the `status` field. If it is `failed` or `canceled`, read the `error` field. Failed and cancelled predictions are not billed.

## 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.


Turn an image and a prompt into a 480p or 720p video with a Pruna AI optimized Wan 2.2 A14B API. From $0.06 per video, pay as you go.