Name: Image Animation from Video API (P-Video Animate)
Brand: magicapi
SKU: api-magicapi-image-animation-with-source-video-prunaai-p-video-animate
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Image Animation API from a Source Video (P-Video Animate)

## Overview
P-Video Animate, from Pruna AI, animates a still image using the motion and audio of a source video. You send a reference image of the subject and an .mp4 source video; the model returns a video of your subject moving the way the source video moves, with the source audio kept by default. Pruna AI built it for speed and cost and reports about 5.24 seconds of processing per 1 second of video.

## Features
- Animates a reference image with the motion of a source video (`image` + `video`, both required)
- Keeps the source audio in the output by default (`save_audio`), or ignores it during generation (`ignore_audio`)
- Optional `instruction_prompt` to guide how the subject is animated
- Two resolution budgets: `720p` (about 1 MP) and `1080p` (about 2 MP), aspect ratio preserved
- Working frame rate: keep the original, or set `24` or `48` FPS
- `turbo` mode for faster generation at slightly lower quality
- Optional `seed` for repeatable runs

## Use Cases
### Character and mascot animation
Make a drawn character, mascot or avatar perform the moves from a reference clip you already have.

### Marketing content
Reuse one performance video to animate several product characters or brand illustrations, keeping the same motion and soundtrack.

### Social and creator video
Animate a portrait or artwork with a dance, gesture or talking clip, keeping the clip's audio.

## Visual Examples
This is the request we ran through api.market (no `instruction_prompt`, all other fields at their defaults).

**Reference image (`image`):** [View the input image](https://blog.api.market/wp-content/uploads/2026/09/kling-v2-6-motion-control-input-character-api-market.webp)

**Source video (`video`):** [Watch the source video](https://blog.api.market/wp-content/uploads/2026/10/hailuo-2.3-fast-output-api-market.mp4)

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

## Pricing
- Pay As You Go (PAYG) pricing: you only pay for what you use.
- Price: $0.038 per API unit.
- 1 API unit = 1 second of output video at 720p, rounded up to a whole unit per request.
- `resolution: "720p"` (the default): 1 unit per second, so $0.038 per second of video.
- `resolution: "1080p"`: 2 units per second, so $0.076 per second of video.
- Worked example: a 5 second output video at 720p is 5 units = $0.19. The same 5 seconds at 1080p is 10 units = $0.38.
- `turbo`, `target_fps` and the audio options 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-animation-with-source-video-prunaai-p-video-animate`

### 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-animation-with-source-video-prunaai-p-video-animate/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
  "version": "cc943ebdaba9cfe80c16979cda16973661810e6fca2647978a1dea060af7bd72",
  "input": {
    "video": "https://blog.api.market/wp-content/uploads/2026/10/hailuo-2.3-fast-output-api-market.mp4",
    "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-6-motion-control-input-character-api-market.webp"
  }
}'
```

Response (`201 Created`):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "cc943ebdaba9cfe80c16979cda16973661810e6fca2647978a1dea060af7bd72",
  "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-animation-with-source-video-prunaai-p-video-animate/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/p-video-animate-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`. `video` and `image` are required; every other field is optional.

| Parameter | Type | Default | Allowed values | Required | Description |
|---|---|---|---|---|---|
| `video` | string (URL) | none | any | Yes | Source RGB video (.mp4) that supplies the motion and audio. |
| `image` | string (URL) | none | any | Yes | Reference image of the subject to animate. |
| `instruction_prompt` | string | `""` | any | No | Further instruction on how the reference subject should be animated using the motion of the input video. |
| `resolution` | string | `"720p"` | `720p`, `1080p` | No | Target megapixel budget: 720p is about 1 MP, 1080p is about 2 MP (aspect ratio preserved). |
| `target_fps` | string | `"original"` | `original`, `24`, `48` | No | Target FPS for the working video. |
| `save_audio` | boolean | `true` | `true`, `false` | No | Save the video with audio. |
| `ignore_audio` | boolean | `false` | `true`, `false` | No | Ignore source audio during generation. If save_audio is true, the source audio is still saved with the final video. |
| `turbo` | boolean | `false` | `true`, `false` | No | Turbo mode: faster generation for slightly lower quality. |
| `disable_safety_checker` | boolean | `false` | `true`, `false` | No | Disable safety checker for generated videos. |
| `seed` | integer | none | any | No | Random seed. Leave blank for random. Optional, can be null. |
| `no_op` | boolean | `false` | `true`, `false` | No | No-op flag with no documented effect. Leave it at `false`. |

### 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-animation-with-source-video-prunaai-p-video-animate";

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: "cc943ebdaba9cfe80c16979cda16973661810e6fca2647978a1dea060af7bd72", 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({
  "video": "https://blog.api.market/wp-content/uploads/2026/10/hailuo-2.3-fast-output-api-market.mp4",
  "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-6-motion-control-input-character-api-market.webp"
}).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-animation-with-source-video-prunaai-p-video-animate"

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": "cc943ebdaba9cfe80c16979cda16973661810e6fca2647978a1dea060af7bd72", "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({
    "video": "https://blog.api.market/wp-content/uploads/2026/10/hailuo-2.3-fast-output-api-market.mp4",
    "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-6-motion-control-input-character-api-market.webp"
}))
```

#### cURL
```bash
# Step 1: create a prediction (returns 201 Created with an id)
curl -X POST "https://prod.api.market/api/v1/magicapi/image-animation-with-source-video-prunaai-p-video-animate/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
  "version": "cc943ebdaba9cfe80c16979cda16973661810e6fca2647978a1dea060af7bd72",
  "input": {
    "video": "https://blog.api.market/wp-content/uploads/2026/10/hailuo-2.3-fast-output-api-market.mp4",
    "image": "https://blog.api.market/wp-content/uploads/2026/09/kling-v2-6-motion-control-input-character-api-market.webp"
  }
}'

# 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-animation-with-source-video-prunaai-p-video-animate/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 `720p` unless you need the larger 1080p output. 1080p costs twice as much per second.
- Trim the source video to the part you need. You pay per second of output video.
- Set `turbo: true` when faster generation matters more than the small loss in quality.
- Poll about once per second and stop polling as soon as the status is final.

## FAQ
**What do I need to send?**
A reference image of the subject (`image`) and a source .mp4 video (`video`) that provides the motion and audio. Both must be publicly reachable URLs.

**Is the source audio kept?**
Yes by default (`save_audio: true`). Set `save_audio: false` to get a silent video. `ignore_audio: true` stops the audio from being used during generation; if `save_audio` is still true, the source audio is still saved with the final video.

**How is a request billed?**
Per second of output video: $0.038 per second at 720p and $0.076 per second at 1080p. Failed or cancelled predictions are not billed.

**Can I guide the animation with text?**
Yes, `instruction_prompt` takes further instructions on how the subject should be animated using the motion of the source video. It is optional.

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


Animate a reference image with the motion and audio of a source video using P-Video Animate from Pruna AI. 720p or 1080p, billed per second of video.