Name: Text, Image and Audio-to-Video API - P-Video-2
Brand: magicapi
SKU: api-magicapi-fast-video-generation-prunaai-p-video-2
Availability: InStock
Author: API Market

Shashank Agarwal

# 📹 Text, Image and Audio-to-Video API (P-Video-2)

## Overview
This API generates video with P-Video-2 from Pruna AI, the quality-focused successor to P-Video. Write a text `prompt` to create a video, add an `image` to animate it (image-to-video), set a `last_frame_image` for the final frame, or give an `audio` track to condition the video on sound. Videos are 1 to 20 seconds long at 720p or 1080p, and a draft mode makes a lower-quality preview at a lower price. The response is a URL to the generated video.

## Features
- **Text-to-video**: `prompt` is the only required field.
- **Image-to-video**: pass `image` (jpg, jpeg, png or webp) to generate the video from that image.
- **Last frame control**: `last_frame_image` sets a reference image for the last frame of the video.
- **Audio conditioning**: pass `audio` (flac, mp3 or wav) to condition video generation on that audio. When audio is provided, `duration` is ignored.
- **Duration from 1 to 20 seconds**: or leave `duration` empty to let the model choose the length from the prompt.
- **Resolution**: `720p` (default) or `1080p`.
- **Frame rate**: `24` (default) or `48` frames per second.
- **Aspect ratio**: `16:9` (default), `9:16`, `4:3`, `3:4`, `3:2`, `2:3` or `1:1`. Ignored when an input image is provided.
- **Draft mode**: `draft` generates a lower-quality preview of the video at half the price.
- **Prompt upsampling**: `prompt_upsampling` (default `true`) enhances your prompt before generation.
- **Other options**: `save_audio` (default `true`) saves the video with audio, `seed` makes results reproducible, and `disable_safety_filter` turns off the safety check on prompts and input images. It defaults to `true` (check off); set it to `false` to have prompts checked for unsafe content before generation.

## Use Cases
1. **Social and marketing video**: Generate short clips for posts and ads from a written idea.
2. **Animating stills**: Bring a product photo or illustration to life with `image`, and control where the shot ends with `last_frame_image`.
3. **Video for existing audio**: Generate visuals that follow a voiceover, music clip or sound effect passed in `audio`.
4. **Fast iteration**: Use `draft` mode to test prompts cheaply, then render the final version without it.

## Visual Examples
### Example Input
**Prompt:**
`A paper boat floating down a rain-soaked street gutter, macro shot, shallow depth of field`

**Settings:** `duration` set to 5 seconds; all other fields at their defaults (720p, 24 fps, 16:9, draft off). No input image or audio was used.

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

## Pricing
- **Pay As You Go (PAYG)**: you only pay for what you use.
- **Price**: $0.019 per API unit.
- **Billing unit**: per second of output video. The number of seconds is rounded up to a whole second and multiplied by the tier for `draft` and `resolution`:
  - **Draft, 720p**: 1 unit per second = **$0.019 per second**
  - **Standard (draft off), 720p** (default): 2 units per second = **$0.038 per second**
  - **Draft, 1080p**: 2 units per second = **$0.038 per second**
  - **Standard (draft off), 1080p**: 4 units per second = **$0.076 per second**
- You are billed for the length of the video you get back. If you leave `duration` empty, or pass `audio`, that is the length the model produces.
- Example: the request on this page (5 seconds, standard, 720p) was 10 units = $0.19. The longest set duration (20 seconds, standard, 1080p) is 80 units = $1.52.
- 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-video-generation-prunaai-p-video-2`

### 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-video-generation-prunaai-p-video-2/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-video-generation-prunaai-p-video-2/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "a97dfc2688ed3109dfa45f6086f26eeb0c7017fb6d805fccc494df9c0c23b32e",
    "input": {
      "prompt": "A paper boat floating down a rain-soaked street gutter, macro shot, shallow depth of field",
      "duration": 5
    }
  }'
```

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

#### GET /api/v1/magicapi/fast-video-generation-prunaai-p-video-2/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-video-generation-prunaai-p-video-2/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "a97dfc2688ed3109dfa45f6086f26eeb0c7017fb6d805fccc494df9c0c23b32e",
  "status": "succeeded",
  "input": {
    "prompt": "A paper boat floating down a rain-soaked street gutter, macro shot, shallow depth of field",
    "duration": 5
  },
  "output": "https://blog.api.market/wp-content/uploads/2026/10/p-video-2-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 | Text prompt for video generation. |
| `image` | string | - | no | Input image to generate video from (image-to-video). Supports jpg, jpeg, png, webp. |
| `last_frame_image` | string | - | no | Reference image for the last frame of the video. Supports jpg, jpeg, png, webp. |
| `audio` | string | - | no | Input audio to condition video generation. Supports flac, mp3, wav. |
| `duration` | integer | - | no | Duration of the video in seconds (1-20). Leave empty to let the model choose length from the prompt. Ignored when audio is provided. Range: 1 to 20. |
| `aspect_ratio` | string | `16:9` | no | Aspect ratio of the video. Ignored when an input image is provided. One of: `16:9`, `9:16`, `4:3`, `3:4`, `3:2`, `2:3`, `1:1`. |
| `resolution` | string | `720p` | no | Resolution of the video. One of: `720p`, `1080p`. |
| `fps` | integer | `24` | no | Frames per second of the video. One of: `24`, `48`. |
| `draft` | boolean | `false` | no | Draft mode. Generates a lower-quality preview of the video. |
| `prompt_upsampling` | boolean | `true` | no | Use prompt upsampling to enhance the prompt. |
| `disable_safety_filter` | boolean | `true` | no | Disable safety filter for prompts (and input image). When disabled, prompts are not checked for unsafe content before generation. |
| `save_audio` | boolean | `true` | no | Save the video with audio. |
| `seed` | integer | - | no | Random seed. Set for reproducible generation. |
| `no_op` | boolean | `false` | no | Health check mode - returns status without inference. |

### 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-video-generation-prunaai-p-video-2";

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: "a97dfc2688ed3109dfa45f6086f26eeb0c7017fb6d805fccc494df9c0c23b32e", 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": "A paper boat floating down a rain-soaked street gutter, macro shot, shallow depth of field",
  "duration": 5
}).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-video-generation-prunaai-p-video-2"

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": "a97dfc2688ed3109dfa45f6086f26eeb0c7017fb6d805fccc494df9c0c23b32e", "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": "A paper boat floating down a rain-soaked street gutter, macro shot, shallow depth of field",
  "duration": 5
})
print(output)
```

#### cURL
```bash
# Step 1: Create a prediction (returns 201 Created)
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-video-generation-prunaai-p-video-2/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "a97dfc2688ed3109dfa45f6086f26eeb0c7017fb6d805fccc494df9c0c23b32e",
    "input": {
      "prompt": "A paper boat floating down a rain-soaked street gutter, macro shot, shallow depth of field",
      "duration": 5
    }
  }'

# 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-video-generation-prunaai-p-video-2/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

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

### Performance Optimization
- Use `draft` mode while you iterate on prompts; it halves the price per second.
- Set `duration` explicitly when you need a predictable cost, since an empty duration lets the model pick the length.
- Keep `720p` for previews and switch to `1080p` only for final renders.

## FAQ
1. **What inputs can I use?**
   - A text `prompt` (required), plus optional `image` for the first frame, `last_frame_image` for the last frame and `audio` to condition the video on sound.

2. **How long are the videos?**
   - 1 to 20 seconds when you set `duration`. If you leave it empty, the model chooses the length from the prompt. When you pass `audio`, `duration` is ignored.

3. **What is draft mode?**
   - `draft: true` generates a lower-quality preview of the video and costs half as much per second as a standard render at the same resolution.

4. **What is `no_op`?**
   - A health check mode that returns status without running inference. Leave it at `false` for normal use.

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.


Generate videos from text, a first-frame image or an audio track with Pruna AI's P-Video-2. 720p or 1080p, 1 to 20 seconds, pay per second.