Name: Image-to-Video Generator API (Wan 2.7)
Brand: magicapi
SKU: api-magicapi-image-to-video-generator-wan-video-wan-2-7-i2v
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Image-to-Video Generator API (Wan 2.7)

## Overview
Wan 2.7 image-to-video is a video generation model from Alibaba. You send a first frame image and a text `prompt`, and it generates a video that starts from that image. It also supports first-and-last-frame control (`last_frame`), continuing an existing video clip (`first_clip`), and synchronizing the video to an audio file (`audio`). When you do not send audio, the model generates matching audio itself.

Each request returns the URL of one video file.

## Features
- **Animate an image**: pass `first_frame` (jpg, png, bmp or webp, up to 20 MB) and describe the motion in `prompt`.
- **First and last frame**: add `last_frame` to set the image the video ends on. `last_frame` requires `first_frame`.
- **Clip continuation**: pass `first_clip` (mp4 or mov, 2 to 10 seconds, up to 100 MB) to continue from an existing video. `first_clip` cannot be combined with `first_frame`.
- **Audio synchronization**: pass `audio` (wav or mp3, 3 to 30 seconds, up to 15 MB) for voice or music synchronization. Without it, the model generates matching audio.
- **Duration**: 2 to 15 seconds with `duration` (default 5).
- **Resolution**: `720p` or `1080p` (default) with `resolution`.
- **Negative prompt**: describe content that should not appear with `negative_prompt`.
- **Prompt expansion**: `enable_prompt_expansion` (default `true`) expands and optimizes the prompt. It improves quality for short prompts but increases latency.
- **Seed**: set `seed` (0 to 2147483647) for reproducible generation.

## Use Cases
1. **Product and marketing clips**: turn a product photo into a short video with camera movement.
2. **Animating artwork**: bring an illustration or still photo to life with a described motion.
3. **Planned transitions**: give a first and a last frame to control where the video starts and ends.
4. **Extending footage**: continue an existing clip with `first_clip` and a new prompt.
5. **Music or voice videos**: sync the video to your own audio track with `audio`.

## Visual Examples
### Example Input
Prompt: "The camera slowly pushes in as she looks up at the glowing neon sign"

First frame (`first_frame`): [view the input image](https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp)

Settings: `resolution` `720p`, `duration` `5`. All other fields were left at their defaults (no audio file was sent, so the model generated the audio).

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

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `first_frame` | string (URL) | No | none |  | First frame image to animate into video (jpg/png/bmp/webp, ≤20MB) |
| `last_frame` | string (URL) | No | none |  | Last frame image for first-and-last-frame video generation (jpg/png/bmp/webp, ≤20MB). Requires first_frame. |
| `first_clip` | string (URL) | No | none |  | Video clip to continue from (mp4/mov, 2-10s, ≤100MB). Cannot be combined with first_frame. |
| `audio` | string (URL) | No | none |  | Audio file (wav/mp3, 3-30s, ≤15MB) for voice/music synchronization. If not provided, the model auto-generates matching audio. |
| `prompt` | string | No | `""` |  | Text prompt for video generation |
| `negative_prompt` | string | No | `""` |  | Negative prompt: describes content that should not appear in the video |
| `resolution` | string | No | `1080p` | `720p`, `1080p` | Output video resolution |
| `duration` | integer | No | `5` | 2 to 15 | Duration of the generated video in seconds |
| `enable_prompt_expansion` | boolean | No | `true` |  | Automatically expand and optimize the prompt for better results. Improves quality for short prompts but increases latency. |
| `seed` | integer | No | none | 0 to 2147483647 | Random seed for reproducible generation. Range: 0-2147483647 |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.125 per API unit.
- **1 API unit = 1 second of 720p output video.** Seconds are the length of the video returned (normally the `duration` you set, default 5), rounded up to whole seconds.
- **`resolution` `720p`**: 1 unit per second, so $0.125 per second.
- **`resolution` `1080p`** (the default): 1.5 units per second, so $0.1875 per second. The total for a request is rounded up to a whole unit.
- **Worked examples**:
  - 5 second video at 720p: 5 units, $0.625.
  - 5 second video at 1080p: 7.5 units, rounded up to 8 units, $1.00.
  - 10 second video at 1080p: 15 units, $1.875.
  - 15 second video at 1080p: 22.5 units, rounded up to 23 units, $2.875.
- A request that does not set `resolution` uses the default `1080p` and is billed at 1.5 units per second.
- **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 go to: `https://prod.api.market/api/v1/magicapi/image-to-video-generator-wan-video-wan-2-7-i2v`

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

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/image-to-video-generator-wan-video-wan-2-7-i2v/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "b2d9c361e32024e17b7080c0bd351775be2a8cf732e04a4feb11c8653a40b1c1",
    "input": {
      "first_frame": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp",
      "prompt": "The camera slowly pushes in as she looks up at the glowing neon sign",
      "resolution": "720p",
      "duration": 5
    }
  }'
```

Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "b2d9c361e32024e17b7080c0bd351775be2a8cf732e04a4feb11c8653a40b1c1",
  "status": "starting",
  "created_at": "2026-10-13T10:34:52.464Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/image-to-video-generator-wan-video-wan-2-7-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.7-i2v-output-api-market.mp4",
  "error": null,
  "created_at": "2026-10-13T10:34:52.464Z",
  "started_at": "2026-10-13T10:34:53.464Z",
  "completed_at": "2026-10-13T10:38:37.464Z"
}
```

`output` is the URL of one video file.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a `duration` outside 2 to 15, or `first_clip` combined with `first_frame`.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry 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.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## 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-wan-video-wan-2-7-i2v";

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

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

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

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    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(pollInterval);
  }

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

createAndWaitForPrediction({
      "first_frame": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp",
      "prompt": "The camera slowly pushes in as she looks up at the glowing neon sign",
      "resolution": "720p",
      "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-wan-video-wan-2-7-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": "b2d9c361e32024e17b7080c0bd351775be2a8cf732e04a4feb11c8653a40b1c1", "input": input_data},
    )

    if response.status_code != 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({
    "first_frame": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-1-input-api-market.webp",
    "prompt": "The camera slowly pushes in as she looks up at the glowing neon sign",
    "resolution": "720p",
    "duration": 5
}))
```

## FAQ
- **Which inputs do I need to send?**
  - The usual request is `first_frame` plus a `prompt`. To continue a video, send `first_clip` plus a `prompt` instead. `first_clip` cannot be combined with `first_frame`, and `last_frame` requires `first_frame`.
- **Can I use my own audio?**
  - Yes. Send a wav or mp3 file (3 to 30 seconds, up to 15 MB) in `audio`. Without it, the model generates matching audio.
- **How is a 1080p video billed?**
  - At 1.5 units per second, rounded up to a whole unit per request. A 5 second 1080p video costs 8 units ($1.00).
- **How long does a prediction take?**
  - It varies by request. Poll every second and stop after 10 minutes.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

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


Generate 2 to 15 second videos from an image with Alibaba's Wan 2.7: first and last frame control, clip continuation and audio sync, at 720p or 1080p.