Name: Fast Text/Image/Audio-to-Video API - prunaai/p-video
Brand: magicapi
SKU: api-magicapi-fast-ai-video-generation-prunaai-p-video
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Fast Text/Image/Audio-to-Video API (prunaai/p-video)

## Overview
The Fast Text/Image/Audio-to-Video API by prunaai/p-video allows for rapid video generation from text, images, or audio. The API supports draft mode for quick creative iterations, providing a single endpoint for text-to-video, image-to-video, and audio-to-video transformations.

## Features
- **Rapid Video Generation**: Quickly create videos from text, images, or audio inputs.
- **Draft Mode**: Generate lower-quality previews for faster iterations.
- **Single Endpoint**: Simplifies the process by providing a unified endpoint for multiple input types.
- **Customizable Parameters**: Control aspects such as frame rate, resolution, duration, and more.

## Use Cases
### Marketing and Advertising
Generate engaging video content quickly for social media campaigns, product advertisements, and presentations.

### Education and Training
Create instructional videos, educational content, and training materials faster and more efficiently.

### Social Media Content Creation
Produce original videos for social media channels, including Instagram, TikTok, and YouTube.

### Entertainment Industry
Generate scenes and clips for movies, TV shows, and animations using text or image prompts.

### Corporate Communications
Create video messages, announcements, and presentations for internal and external communications.

## Visual Examples

### Example Input

```json
{
  "input": {
    "prompt": "A friendly cartoon robot mascot waves at the camera and says: \"This is how you generate a video on api.market in seconds.\"",
    "duration": 5,
    "resolution": "1080p",
    "draft": false
  }
}
```

### Example Output

![Example output](https://blog.api.market/wp-content/uploads/2026/09/p-video-output-api-market.mp4)

This exact request was run through api.market and billed 40 API units ($0.252).
## Pricing
- Pay As You Go (PAYG) pricing - you only pay for what you use
- Price: $0.0063 per API unit
- 1 API unit = 1 second of output video, rounded up to whole seconds
- The base rate applies to requests with draft: true and resolution: "720p"
- Requests with draft: true and resolution: "1080p" count as 2 units per second, rounded up to whole units per request (a 5 second clip bills 10 units)
- Requests with draft: false and resolution: "720p" count as 4 units per second, rounded up to whole units per request (a 5 second clip bills 20 units)
- Requests with draft: false and resolution: "1080p" count as 8 units per second, rounded up to whole units per request (a 5 second clip bills 40 units)
- A request that does not choose a variant uses the model default and counts as 4 units per second (a 5 second clip bills 20 units)
- Failed or cancelled predictions are not billed
- GET requests to check prediction status (`GET /api/v1/magicapi/fast-ai-video-generation-prunaai-p-video/predictions/{id}`) 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-ai-video-generation-prunaai-p-video`

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

### Asynchronous Processing
**IMPORTANT**: This API uses asynchronous processing for predictions. The typical flow is:
1. Submit a prediction request to the POST endpoint
2. Receive a prediction ID in the response
3. Poll the GET endpoint with the prediction ID to check status
4. Continue polling until the prediction is complete

The processing time varies depending on the complexity of the request. Your code should implement:
- A polling interval of 1 second between status checks
- A maximum timeout of 600 seconds (10 minutes)
- Status checking logic that continues while status is "starting" or "processing"
- Result handling when status becomes "succeeded"
- Error handling when status becomes "failed" or "canceled", or timeout is reached

### Endpoints
#### Create a Prediction
**Endpoint**: `POST /api/v1/magicapi/fast-ai-video-generation-prunaai-p-video/predictions`

**Example Request:**
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-ai-video-generation-prunaai-p-video/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "50e52eaadc2a1648c1c4f854695c2ac7d56c23068802e8cafb8b69f1100b9ece",
    "input": {
      "prompt": "A friendly cartoon robot mascot waves at the camera and says: \"This is how you generate a video on api.market in seconds.\"",
      "duration": 5,
      "resolution": "1080p",
      "draft": false
    }
  }'
```

#### Check Prediction Status
**Endpoint**: `GET /api/v1/magicapi/fast-ai-video-generation-prunaai-p-video/predictions/{id}`

**Example Request:**
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-ai-video-generation-prunaai-p-video/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Status Codes
- **200 OK**: Request successful
- **201 Created**: Resource successfully created
- **400 Bad Request**: Invalid input parameters or malformed request
- **401 Unauthorized**: Missing or invalid API key
- **403 Forbidden**: Valid API key but insufficient permissions
- **404 Not Found**: Resource not found
- **429 Too Many Requests**: Rate limit exceeded
- **500 Internal Server Error**: Server-side error
- **503 Service Unavailable**: Service temporarily unavailable

### Rate Limits
Include information about any rate limits and how to handle them.

### Error Handling
Provide detailed guidance on error handling best practices, including:
- How to interpret error responses
- Common errors and how to resolve them
- Recommended retry strategies for transient errors

Show error response examples in JSON format with proper code highlighting:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```

### Implementation Guide
#### Example Code
**JavaScript (Node.js)**
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/fast-ai-video-generation-prunaai-p-video";

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

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const prediction = await response.json();
    const predictionId = prediction.id;

    // Step 2: Poll for results with timeout
    return await pollForResults(predictionId);
  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

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) {
    // Check prediction status
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-api-market-key": apiKey
      }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const prediction = await response.json();

    // Check status and return if completed
    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    // Handle failure
    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    // Wait before next poll
    await delay(POLL_INTERVAL);
  }

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

**Python**
```python
# Python example with proper polling and timeout
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/fast-ai-video-generation-prunaai-p-video"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }

    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "50e52eaadc2a1648c1c4f854695c2ac7d56c23068802e8cafb8b69f1100b9ece", "input": input_data}
    )

    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")

    prediction = response.json()
    prediction_id = prediction["id"]

    # Step 2: Poll for results with timeout
    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:
        # Check prediction status
        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()

        # Check status and return if completed
        if prediction["status"] == "succeeded":
            return prediction["output"]

        # Handle failure
        if prediction["status"] in ("failed", "canceled"):
            error_msg = prediction.get("error") or "Unknown error"
            raise Exception(f"Prediction {prediction['status']}: {error_msg}")

        # Wait before next poll
        time.sleep(POLL_INTERVAL)

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

**cURL**
```bash
# cURL example
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-ai-video-generation-prunaai-p-video/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "50e52eaadc2a1648c1c4f854695c2ac7d56c23068802e8cafb8b69f1100b9ece",
    "input": {
      "prompt": "A friendly cartoon robot mascot waves at the camera and says: \"This is how you generate a video on api.market in seconds.\"",
      "duration": 5,
      "resolution": "1080p",
      "draft": false
    }
  }'

# Response will contain a prediction ID like:
# {"id": "abcd1234", "status": "starting"}

# Step 2: Check prediction status (replace abcd1234 with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-ai-video-generation-prunaai-p-video/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Note: You need to repeatedly poll this endpoint manually until status is "succeeded"
```

### Performance Optimization
Tips for optimizing API usage and minimizing costs:
- Use draft mode for quick previews before finalizing the video.
- Choose lower resolutions when high quality is not necessary to reduce costs.
- Optimize input prompts for clarity and conciseness.

## FAQ
Include a list of frequently asked questions and their answers.

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

## Input Parameters
| Parameter          | Type        | Default   | Allowed Values                          | Required | Description                                                             |
|--------------------|-------------|-----------|-----------------------------------------|----------|-------------------------------------------------------------------------|
| `fps`              | integer     | 24        | [24, 48]                                | No       | Frames per second of the video.                                         |
| `seed`             | integer     |           |                                         | No       | Random seed. Set for reproducible generation.                           |
| `audio`            | string      |           | URI format, supports flac, mp3, wav     | No       | Input audio to condition video generation.                              |
| `draft`            | boolean     | false     | [true, false]                           | No       | Draft mode. Generates a lower-quality preview of the video.             |
| `image`            | string      |           | URI format, supports jpg, jpeg, png, webp | No     | Input image to generate video from (image-to-video).                    |
| `no_op`            | boolean     | false     | [true, false]                           | No       | Health check mode - returns status without inference.                   |
| `prompt`           | string      |           |                                         | Yes      | Text prompt for video generation.                                       |
| `duration`         | integer     | 5         | 1-20                                    | No       | Duration of the video in seconds (1-20). Ignored when audio is provided. |
| `resolution`       | string      | 720p      | [720p, 1080p]                           | No       | Resolution of the video.                                                |
| `save_audio`       | boolean     | true      | [true, false]                           | No       | Save the video with audio.                                              |
| `aspect_ratio`     | string      | 16:9      | [16:9, 9:16, 4:3, 3:4, 3:2, 2:3, 1:1]   | No       | Aspect ratio of the video. Ignored when an input image is provided.     |
| `last_frame_image` | string      |           | URI format, supports jpg, jpeg, png, webp| No       | Reference image for the last frame of the video.                        |
| `prompt_upsampling`| boolean     | true      | [true, false]                           | No       | Use prompt upsampling to enhance the prompt.                            |
| `disable_safety_filter` | boolean | true     | [true, false]                           | No       | Disable safety filter for prompts (and input image).                    |

Be comprehensive but avoid unnecessary repetition. Focus on providing practical, useful information that helps developers understand how to use the API effectively.

Generate high-quality videos from text, images, or audio swiftly. Leverage prunaai/p-video for rapid video creation and creative iteration.