Name: Image-to-Video API with Audio (Alibaba Wan 2.5)
Brand: magicapi
SKU: api-magicapi-image-to-video-generator-background-audio-wan-video-wan-2-5-i2v
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Image-to-Video Generator API with Background Audio (Wan 2.5)

## Overview
Wan 2.5 image-to-video, from Alibaba, turns a still image and a text prompt into a 5 or 10 second video with background audio. You can also pass your own audio file (wav or mp3) for voice or music synchronization. Output is available at 480p, 720p or 1080p.

## Features
- Image-to-video: an input `image` plus a text `prompt` (both required)
- Video with background audio
- Optional `audio` file (wav/mp3, 3 to 30 seconds, up to 15 MB) for voice or music synchronization
- `duration` of 5 or 10 seconds
- `resolution` of `480p`, `720p` (default) or `1080p`
- `negative_prompt` to steer away from unwanted elements
- `enable_prompt_expansion` (on by default) turns on the prompt optimizer
- Optional `seed` for reproducible generation

## Use Cases
### Product and marketing clips
Animate a product photo or campaign image into a short clip with sound for ads and social posts.

### Music and voice content
Pass a song or voice track as `audio` to generate a video synchronized to it from a single cover image or portrait.

### Storytelling from stills
Bring illustrations, photos or concept art to life with a prompt describing the motion you want.

## Visual Examples
This is the request we ran through api.market.

**Input image (`image`):** [View the input image](https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp)

**Prompt:** "Rain keeps falling as she turns her head and smiles"

**Settings:** `resolution: "480p"`, `duration: 5`

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

## Pricing
- Pay As You Go (PAYG) pricing: you only pay for what you use.
- Price: $0.063 per API unit.
- 1 API unit = 1 second of output video at 480p. Units are the requested `duration` times the resolution factor, rounded up to a whole unit per request.
- `resolution: "480p"`: 1 unit per second, so $0.063 per second of video.
- `resolution: "720p"` (the default): 2 units per second, so $0.126 per second of video.
- `resolution: "1080p"`: 3 units per second, so $0.189 per second of video.
- Worked example: a 5 second video at 480p (like the example above) is 5 units = $0.315. A request with no `resolution` or `duration` uses the defaults (720p, 5 seconds) and is 10 units = $0.63. A 10 second video at 1080p is 30 units = $1.89.
- `audio`, `negative_prompt`, `enable_prompt_expansion` and `seed` do not change the price.
- 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/image-to-video-generator-background-audio-wan-video-wan-2-5-i2v`

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

### Asynchronous Processing
This API is asynchronous:
1. Send a POST request to `/predictions`. A successful request returns `201 Created` with a prediction `id` and a `status` of `starting` or `processing`. 201 means the job was accepted; it is not an error.
2. Poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
3. When `status` is `succeeded`, `output` holds the generated video as a URL.

Your code should:
- Wait about 1 second between status checks.
- Stop after a timeout you choose (the examples below use 600 seconds).
- Keep polling while `status` is `starting` or `processing`.
- Read `output` when `status` is `succeeded`.
- Handle `failed` and `canceled` (read the `error` field) and the timeout case.

### Endpoints
#### POST /predictions
Create a prediction. This is the request we ran for the example above.

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/image-to-video-generator-background-audio-wan-video-wan-2-5-i2v/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
  "version": "1b29bbbbfdbc25bba2294de3acd2b58b82e5b623f183880cdb37d76133d80f00",
  "input": {
    "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp",
    "prompt": "Rain keeps falling as she turns her head and smiles",
    "resolution": "480p",
    "duration": 5
  }
}'
```

Response (`201 Created`):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "1b29bbbbfdbc25bba2294de3acd2b58b82e5b623f183880cdb37d76133d80f00",
  "status": "starting",
  "created_at": "2026-10-13T11:11:59.334Z"
}
```

#### GET /predictions/{id}
Get the status and result of a prediction.

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

Response when the prediction has finished (`200 OK`):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/wan-2.5-i2v-output-api-market.mp4",
  "created_at": "2026-10-13T11:11:59.334Z",
  "started_at": "2026-10-13T11:12:01.000Z",
  "completed_at": "2026-10-13T11:13:00.000Z"
}
```

### Status Codes
- 200 OK: Status request successful
- 201 Created: Prediction created (success)
- 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
- 503 Service Unavailable: Service temporarily unavailable

### Input Parameters
Send these fields inside `input`. `image` and `prompt` are required.

| Parameter | Type | Default | Allowed values | Required | Description |
|---|---|---|---|---|---|
| `image` | string (URL) | none | any | Yes | Input image for video generation. |
| `prompt` | string | none | any | Yes | Text prompt for video generation. |
| `negative_prompt` | string | `""` | any | No | Negative prompt to avoid certain elements. |
| `audio` | string (URL) | none | any | No | Audio file (wav/mp3, 3 to 30 seconds, up to 15 MB) for voice/music synchronization. Optional, can be null. |
| `resolution` | string | `"720p"` | `480p`, `720p`, `1080p` | No | Video resolution. |
| `duration` | integer | `5` | `5`, `10` | No | Duration of the generated video in seconds. |
| `enable_prompt_expansion` | boolean | `true` | `true`, `false` | No | If set to true, the prompt optimizer will be enabled. |
| `seed` | integer | none | any | No | Random seed for reproducible generation. Optional, can be null. |

### 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/image-to-video-generator-background-audio-wan-video-wan-2-5-i2v";

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: "1b29bbbbfdbc25bba2294de3acd2b58b82e5b623f183880cdb37d76133d80f00", input: inputData })
  });

  // 201 Created is the normal success response
  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;
  const POLL_INTERVAL = 1000;
  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({
  "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp",
  "prompt": "Rain keeps falling as she turns her head and smiles",
  "resolution": "480p",
  "duration": 5
}).then(output => console.log(output));
```

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

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

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": "1b29bbbbfdbc25bba2294de3acd2b58b82e5b623f183880cdb37d76133d80f00", "input": input_data},
    )
    # 201 Created is the normal success response
    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])

def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    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"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

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

print(create_and_wait_for_prediction({
    "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp",
    "prompt": "Rain keeps falling as she turns her head and smiles",
    "resolution": "480p",
    "duration": 5
}))
```

#### cURL
```bash
# Step 1: create a prediction (returns 201 Created with an id)
curl -X POST "https://prod.api.market/api/v1/magicapi/image-to-video-generator-background-audio-wan-video-wan-2-5-i2v/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
  "version": "1b29bbbbfdbc25bba2294de3acd2b58b82e5b623f183880cdb37d76133d80f00",
  "input": {
    "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp",
    "prompt": "Rain keeps falling as she turns her head and smiles",
    "resolution": "480p",
    "duration": 5
  }
}'

# Step 2: check the prediction status (replace PREDICTION_ID with the id from step 1)
curl -X GET "https://prod.api.market/api/v1/magicapi/image-to-video-generator-background-audio-wan-video-wan-2-5-i2v/predictions/PREDICTION_ID" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

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

### Performance Optimization
- Use `480p` for drafts and previews. It costs a third of 1080p per second.
- Use `duration: 5` unless you need 10 seconds. You pay per second of video.
- `enable_prompt_expansion` (on by default) runs a prompt optimizer. Turn it off if you want your prompt used without changes.
- Poll about once per second and stop polling as soon as the status is final.

## FAQ
**What do I need to send?**
An input image URL (`image`) and a text prompt (`prompt`). Everything else is optional.

**Can I use my own soundtrack or voice?**
Yes. Pass a wav or mp3 URL in `audio` (3 to 30 seconds, up to 15 MB) for voice or music synchronization.

**What lengths and resolutions are available?**
5 or 10 seconds, at 480p, 720p or 1080p. The default is 5 seconds at 720p.

**How is a request billed?**
Per second of video: $0.063 per second at 480p, $0.126 at 720p and $0.189 at 1080p. Failed or 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.


Image-to-video with background audio using Alibaba Wan 2.5: 5 or 10 second videos from an image and prompt, audio sync, 480p to 1080p, billed per second.