Name: Pruna AI P-Video 2 Pro Reference-to-Video Generator API
Brand: magicapi
SKU: api-magicapi-reference-to-video-generator-prunaai-p-video-2-pro-reference
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Reference-to-Video Generator API (Pruna AI P-Video 2 Pro Reference)

## Overview
P-Video 2 Pro Reference is a reference-to-video model from Pruna AI. Its developer describes it as built on MiniMax H3 and generating 5 to 15 second videos from a prompt plus up to 9 images, 3 videos and 3 audio clips, with speed and cost modes.

Send a `prompt` and, optionally, reference `image`, `video` and `audio` files, a `first_frame_image` and a `last_frame_image`. Each request returns the URL of one MP4 video.

## Features
- **References**: condition the video on reference images (`image`), videos (`video`) and audio (`audio`); the developer gives limits of 9 images, 3 videos and 3 audio clips.
- **First and last frame**: `first_frame_image` and `last_frame_image` set where the video starts and ends.
- **Keep your audio**: `keep_audio` uses a single audio file as the soundtrack and generates the video to match it.
- **Duration**: 5 to 15 seconds (`duration`, default 5).
- **Resolution**: `480p`, `768p` (default), `1080p`, `2k` or `4k`. 1080p, 2k and 4k are generated at 768p and upscaled (24 fps kept).
- **Speed or cost mode**: `speed` (default) runs on 4 GPUs; `cost` runs the same model on one GPU, slower and cheaper.
- **Prompt upsampling**: `turbo` (default), `max` (MiniMax, falls back to turbo) or `off`. With `adaptive` aspect ratio, turbo also picks the ratio.
- **Aspect ratios**: `16:9` (default), `adaptive`, `9:16`, `4:3`, `3:4`, `3:2`, `2:3`, `1:1`.

## Use Cases
1. **Animate a product or character**: turn reference photos into a moving shot that keeps their look.
2. **Storyboards to clips**: set the first and last frame and describe the action in between.
3. **Music and voice-led videos**: generate a video that matches an audio track you keep as the soundtrack.
4. **Social and ad clips**: short videos in landscape, portrait or square formats.

## Visual Examples
### Example Input
Our giraffe photo as the only reference image, with the prompt "The giraffe from the reference image walks slowly across a sunny grassy savanna, gently swinging its long neck. The camera tracks alongside at a steady pace. Natural ambience with birdsong and wind, no music.", 5 seconds at `480p` in `cost` mode with `adaptive` aspect ratio and the `turbo` prompt upsampler.

![Reference image: a giraffe standing in a grassy savanna](https://blog.api.market/wp-content/uploads/2026/10/rmgb-input-api-market.jpg)

```json
{
  "mode": "cost",
  "image": [
    "https://blog.api.market/wp-content/uploads/2026/10/rmgb-input-api-market.jpg"
  ],
  "prompt": "The giraffe from the reference image walks slowly across a sunny grassy savanna, gently swinging its long neck. The camera tracks alongside at a steady pace. Natural ambience with birdsong and wind, no music.",
  "duration": 5,
  "resolution": "480p",
  "aspect_ratio": "adaptive",
  "prompt_upsampler": "turbo"
}
```

### Example Output
[Watch the example output](https://blog.api.market/wp-content/uploads/2026/11/p-video-2-pro-reference-output-ydkvcqwp-api-market.mp4)

The 5-second portrait clip shows the giraffe walking through the savanna with natural ambient sound.

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text prompt for video generation. |
| `image` | array of URLs | No | none |  | Reference images (URLs) to condition the generation on. |
| `video` | array of URLs | No | none |  | Reference videos (URLs) to condition the generation on. |
| `audio` | array of URLs | No | none |  | Reference audio files (URLs) to condition the generation on. Set keep_audio to use a single file as the video's audio. |
| `keep_audio` | boolean | No | `false` |  | Keep the uploaded audio as the video's audio instead of only using it as a reference. Needs exactly one audio file. The video is generated to match it. If the audio is shorter than duration, the video plays it first and the model generates the rest. If it is longer, it is cut to duration. If it is within 1 s of duration, the video's length follows the audio's. |
| `duration` | integer | No | `5` | 5 to 15 | Video duration in seconds. With keep_audio, an audio file within 1 s of it sets the length instead. |
| `resolution` | string | No | `768p` | `768p`, `480p`, `1080p`, `2k`, `4k` | Video resolution. 1080p, 2k and 4k generate at 768p and upscale it (24 fps kept). |
| `aspect_ratio` | string | No | `16:9` | `adaptive`, `16:9`, `9:16`, `4:3`, `3:4`, `3:2`, `2:3`, `1:1` | Aspect ratio of the generated video. adaptive uses the most common one among the reference images and videos. |
| `seed` | integer | No | none |  | Random seed for reproducible generation. |
| `mode` | string | No | `speed` | `speed`, `cost` | speed runs on 4 GPUs; cost runs the same model on one GPU (slower, cheaper). |
| `first_frame_image` | string (URL) | No | none |  | Optional image (URL) the video should open on. Combines with the other references. Needs prompt upsampling, so prompt_upsampler off runs turbo when a start or end frame is given. |
| `last_frame_image` | string (URL) | No | none |  | Optional image (URL) the video should end on. Combines with the other references. |
| `prompt_upsampler` | string | No | `turbo` | `turbo`, `max`, `off` | Rewrite the prompt into a detailed brief that looks at the references first: turbo, max (MiniMax; falls back to turbo), or off. With adaptive aspect ratio, turbo also picks the ratio. |
| `enable_safety_filter` | boolean | No | `false` |  | Check the inputs against the content policy. When off, only the always-on categories (sexual content involving minors, self-harm intent or instructions) are still blocked. |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.001 per API unit.
- **Metered billing**: a request is billed for what it uses, summed over each priced item (seconds of output video, reference images, seconds of reference video and seconds of reference audio), then rounded up to a whole API unit.
- **Price by setting**:

| `mode` | `resolution` | Per second of output video | Per reference image | Per second of reference video | Per second of reference audio |
| --- | --- | --- | --- | --- | --- |
| `cost` | `480p` | $0.0177 | $0.00589 | $0.0353 | $0.00177 |
| `cost` | `768p` | $0.0295 | $0.00589 | $0.0706 | $0.00177 |
| `cost` | `1080p` | $0.053 | $0.00589 | $0.0706 | $0.00177 |
| `cost` | `2k` | $0.0765 | $0.00589 | $0.0706 | $0.00177 |
| `cost` | `4k` | $0.124 | $0.00589 | $0.0706 | $0.00177 |
| `speed` | `480p` | $0.0236 | $0.0118 | $0.0471 | $0.00295 |
| `speed` | `768p` | $0.0412 | $0.0118 | $0.0706 | $0.00295 |
| `speed` | `1080p` | $0.0648 | $0.0118 | $0.0706 | $0.00295 |
| `speed` | `2k` | $0.0883 | $0.0118 | $0.0706 | $0.00295 |
| `speed` | `4k` | $0.136 | $0.0118 | $0.0706 | $0.00295 |

- When `mode` and `resolution` are left out, `speed` at `768p` applies: a default 5-second video with no references costs 206 units ($0.206).
- Seconds of output video are the length of the returned video. Reference images count `image`, `first_frame_image` and `last_frame_image`; reference video and audio seconds are the lengths of the files in `video` and `audio`.
- **Example cost**: the example returned 5 seconds of video at `cost` and `480p` with 1 reference image: 5 x $0.0177 + 1 x $0.00589 = $0.0944, rounded up to 95 units ($0.095).
- **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/reference-to-video-generator-prunaai-p-video-2-pro-reference`

### 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/reference-to-video-generator-prunaai-p-video-2-pro-reference/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "prunaai/p-video-2-pro-reference",
    "input": {
      "mode": "cost",
      "image": [
        "https://blog.api.market/wp-content/uploads/2026/10/rmgb-input-api-market.jpg"
      ],
      "prompt": "The giraffe from the reference image walks slowly across a sunny grassy savanna, gently swinging its long neck. The camera tracks alongside at a steady pace. Natural ambience with birdsong and wind, no music.",
      "duration": 5,
      "resolution": "480p",
      "aspect_ratio": "adaptive",
      "prompt_upsampler": "turbo"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "ydkvcqwpgdrmt0d1n17r2fkmcc",
  "version": "prunaai/p-video-2-pro-reference",
  "status": "starting",
  "created_at": "2026-11-04T20:45:50.595Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/reference-to-video-generator-prunaai-p-video-2-pro-reference/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "ydkvcqwpgdrmt0d1n17r2fkmcc",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/11/p-video-2-pro-reference-output-ydkvcqwp-api-market.mp4",
  "error": null,
  "created_at": "2026-11-04T20:45:50.595Z",
  "started_at": "2026-11-04T20:45:50.610Z",
  "completed_at": "2026-11-04T20:46:05.820Z"
}
```

`output` is a single URL string pointing to the generated MP4 video.

### 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 missing `prompt` or a `duration` outside 5 to 15.
- **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
Requests are rate limited to keep usage fair. If you receive a 429 response, wait and retry with exponential backoff.

## 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/reference-to-video-generator-prunaai-p-video-2-pro-reference";

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: "prunaai/p-video-2-pro-reference", 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({
  "mode": "cost",
  "image": [
    "https://blog.api.market/wp-content/uploads/2026/10/rmgb-input-api-market.jpg"
  ],
  "prompt": "The giraffe from the reference image walks slowly across a sunny grassy savanna, gently swinging its long neck. The camera tracks alongside at a steady pace. Natural ambience with birdsong and wind, no music.",
  "duration": 5,
  "resolution": "480p",
  "aspect_ratio": "adaptive",
  "prompt_upsampler": "turbo"
}).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/reference-to-video-generator-prunaai-p-video-2-pro-reference"


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": "prunaai/p-video-2-pro-reference", "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({
    "mode": "cost",
    "image": [
        "https://blog.api.market/wp-content/uploads/2026/10/rmgb-input-api-market.jpg"
    ],
    "prompt": "The giraffe from the reference image walks slowly across a sunny grassy savanna, gently swinging its long neck. The camera tracks alongside at a steady pace. Natural ambience with birdsong and wind, no music.",
    "duration": 5,
    "resolution": "480p",
    "aspect_ratio": "adaptive",
    "prompt_upsampler": "turbo"
}))
```

## FAQ
- **Do I need reference files?**
  - No. Only `prompt` is required. Reference images, videos, audio and first or last frames are optional.
- **What is the difference between `speed` and `cost` mode?**
  - Both run the same model. `speed` (default) runs on 4 GPUs and finishes sooner; `cost` runs on one GPU, takes longer and has lower prices (see the table).
- **Does 4k render natively?**
  - No. `1080p`, `2k` and `4k` are generated at 768p and upscaled, keeping 24 fps.
- **Can I use my own soundtrack?**
  - Yes. Send one file in `audio` and set `keep_audio` to `true`. The video is generated to match it; an audio file within 1 second of `duration` sets the video's length.
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
- **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, reach out to us through the chat on the bottom right of the page.


Create 5 to 15 second videos from a prompt plus reference images, videos and audio with Pruna AI's P-Video 2 Pro Reference, 480p to 4k. From $0.0177 per second, pay as you go.