Name: Video Utils – Process & Convert Clips | Free · $10/mo | API.market
Brand: magicapi
SKU: api-magicapi-ai-video-processing-utilities-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Versatile AI Video Processing Utilities API (video-utils)

## Overview
This API offers a range of tools for automated video processing, editing, and transformation. Whether you need to convert video formats, extract frames, reverse videos, or create preview clips, this AI-powered API provides reliable performance for creative workflows. 

## Features
- Convert input files to MP4 or GIF with adjustable framerate settings
- Extract audio from video and save it as MP3
- Merge zipped frames into MP4 or GIF
- Reverse or bounce videos
- Extract frames from a video for further processing
- Create short preview videos for quick demos or highlights

## Use Cases
1. • E-commerce Product Demos: Convert raw product videos into short, optimized preview clips that load faster on product pages.  
2. • Social Media Marketing: Quickly convert large MP4s to GIFs or short preview videos for platforms like Twitter, Reddit, or Facebook.  
3. • Video Post-Production: Automate frame extraction and reassembly to streamline special effects or transitions in film editing.  
4. • E-Learning Platforms: Convert lectures or screen recordings to optimized GIFs or MP4s for faster loading and better engagement.  
5. • Audio Extraction for Podcasts: Extract the MP3 audio track from a video lecture or webinar, hosted on your own servers or streaming platforms.

## Visual Examples

Below is an example of an input video used in the documentation examples:

![Example input video taken from the schema](https://replicate.delivery/pbxt/Mr0wXFtyPY2zqhynFgNU7xMUhyhJsYja4gTSsJFZKf3Ev4vP/WCtrxBhe2SQ_wbgFI7Li-.mp4)

And here is an example of an output preview video after processing:

![Example output video preview](https://replicate.delivery/xezq/RfzYWEjBLySUGSlON3UtmVXowoOTufqSDuHlKVRoBNPrGwjUA/preview.mp4)

These demonstrate the type of transformations the API can perform, such as creating preview clips from full-length videos.

## Pricing
- 1 API unit equals 1 video processed.  
- GET requests to check prediction status (GET /api/v1/magicapi/ai-video-processing-utilities-api/predictions/{id}) are free and do not count toward API unit usage.  
- Different pricing tiers are available based on usage volume. Contact us for more information on bulk or enterprise plans.

## API Documentation

### Base URL
All API requests should be made to:
```
https://prod.api.market/api/v1/magicapi/ai-video-processing-utilities-api
```

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

### Asynchronous Processing
This API uses asynchronous processing for predictions. Typical flow:
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.

You should:
- Wait about 1 second between status checks.  
- Define a 600-second (10-minute) timeout for the polling loop.  
- Check the status field and handle success (succeeded) or failure (failed) appropriately.

### Endpoints

#### 1) Create a Prediction 
POST /api/v1/magicapi/ai-video-processing-utilities-api/predictions

Create a new prediction for video processing.

• Request Body Parameters  
  - version: (string) Model version ID. Default is "184c9defb94427bfe24cb5151d7edc003caba876ae20f1f635f848d837077b90".  
  - input: (object) Parameters for the video processing task.  
    • task: Required. Specifies the task to perform (e.g., "convert_input_to_mp4", "reverse_video", etc.).  
    • input_file: Required. URL of the video (or ZIP of frames) to process.  
    • fps: (integer) Frames per second for conversions. 0 keeps the original framerate (or a default).

• Example Request
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-video-processing-utilities-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "184c9defb94427bfe24cb5151d7edc003caba876ae20f1f635f848d837077b90",
    "input": {
      "task": "create_preview_video",
      "input_file": "https://replicate.delivery/pbxt/Mr0wXFtyPY2zqhynFgNU7xMUhyhJsYja4gTSsJFZKf3Ev4vP/WCtrxBhe2SQ_wbgFI7Li-.mp4",
      "fps": 0
    }
  }'
```
• Example Success Response (HTTP 201)
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "184c9defb94427bfe24cb5151d7edc003caba876ae20f1f635f848d837077b90",
  "status": "starting",
  "created_at": "2025-05-18T08:21:04.677Z"
}
```

#### 2) Get Prediction Status / Results  
GET /api/v1/magicapi/ai-video-processing-utilities-api/predictions/{id}

Retrieve the status and (if available) the output for a given prediction ID.

• Path Parameters  
  - id: (string) Required. The unique prediction ID returned by the create prediction endpoint.

• Example Request
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-video-processing-utilities-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```
• Example Success Response (HTTP 200)
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": [
    "https://replicate.delivery/xezq/RfzYWEjBLySUGSlON3UtmVXowoOTufqSDuHlKVRoBNPrGwjUA/preview.mp4"
  ],
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```

## Status Codes
- 200 OK: Request successful  
- 201 Created: Resource (prediction) 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 (e.g., invalid prediction ID)  
- 429 Too Many Requests: Rate limit exceeded  
- 500 Internal Server Error: A server-side error occurred  
- 503 Service Unavailable: Service is temporarily unavailable  

## Rate Limits
This API may employ rate limits based on call volume. If you encounter a 429 Too Many Requests error, reduce your request rate or contact us to discuss higher rate limits.

## Error Handling
Error responses are provided in JSON with an "error" field:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```
Recommendation:
- Verify the error code and message carefully.  
- Retry with correct parameters if the error is client-related (4xx series).  
- Implement backoff and retry logic if the error might be transient (e.g., 429 or 503).  

## Implementation Guide

### JavaScript Example

```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ai-video-processing-utilities-api";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-magicapi-key": apiKey
      },
      body: JSON.stringify({
        version: "184c9defb94427bfe24cb5151d7edc003caba876ae20f1f635f848d837077b90",
        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

  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-magicapi-key": apiKey
      }
    });

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

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

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

    await delay(POLL_INTERVAL);
  }

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

// Usage example
(async () => {
  const inputData = {
    task: "create_preview_video",
    input_file: "https://replicate.delivery/pbxt/Mr0wXFtyPY2zqhynFgNU7xMUhyhJsYja4gTSsJFZKf3Ev4vP/WCtrxBhe2SQ_wbgFI7Li-.mp4",
    fps: 0
  };

  try {
    const resultUrls = await createAndWaitForPrediction(inputData);
    console.log("Output URLs:", resultUrls);
  } catch (err) {
    console.error("Failed to process video:", err);
  }
})();
```

### Python Example

```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/ai-video-processing-utilities-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-magicapi-key": API_KEY
    }
    payload = {
        "version": "184c9defb94427bfe24cb5151d7edc003caba876ae20f1f635f848d837077b90",
        "input": input_data
    }

    response = requests.post(f"{BASE_URL}/predictions", headers=headers, json=payload)
    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
    start_time = time.time()

    headers = {"x-magicapi-key": API_KEY}

    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()
        status = prediction["status"]

        if status == "succeeded":
            return prediction["output"]
        elif status == "failed":
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")

        time.sleep(POLL_INTERVAL)

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

# Usage example
if __name__ == "__main__":
    input_data = {
        "task": "create_preview_video",
        "input_file": "https://replicate.delivery/pbxt/Mr0wXFtyPY2zqhynFgNU7xMUhyhJsYja4gTSsJFZKf3Ev4vP/WCtrxBhe2SQ_wbgFI7Li-.mp4",
        "fps": 0
    }
    try:
        results = create_and_wait_for_prediction(input_data)
        print("Output URLs:", results)
    except Exception as e:
        print("Error processing video:", str(e))
```

### cURL Example

```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-video-processing-utilities-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "184c9defb94427bfe24cb5151d7edc003caba876ae20f1f635f848d837077b90",
    "input": {
      "task": "create_preview_video",
      "input_file": "https://replicate.delivery/pbxt/Mr0wXFtyPY2zqhynFgNU7xMUhyhJsYja4gTSsJFZKf3Ev4vP/WCtrxBhe2SQ_wbgFI7Li-.mp4",
      "fps": 0
    }
  }'

# Example response:
# {
#   "id":"ufawqhfynnddngldkgtslldrkq",
#   "status":"starting",
#   "created_at":"2025-05-18T08:21:04.677Z"
# }

# Step 2: Poll the prediction status (replace the ID below with the actual ID from the response)
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-video-processing-utilities-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"

# Keep polling until "status" == "succeeded"
```

### Performance Optimization
- Use batching or parallel requests wisely to avoid rate limit issues.  
- Poll with a 1-second interval to reduce overhead and stay within usage guidelines.  
- Reuse HTTP connections (e.g., in Python `requests.Session` or Node.js persistent connections) to minimize latency.

## FAQ
• Q: What file formats are supported for input?  
  A: You can input standard video files (e.g., MP4, MOV) or a ZIP archive of frames.  

• Q: How long does conversion usually take?  
  A: Most tasks complete within a few seconds. Longer videos or complex tasks can take up to a few minutes.  

• Q: Can I convert large videos to GIF?  
  A: Yes, but note that large GIFs can be memory-intensive. Consider specifying an appropriate FPS to keep file size manageable.  

## 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[at]api.market.

Automate video editing, format conversion, and clip creation. Free 100 calls/mo, from $10/mo. Start free on API.market.

Video Utils – Process & Convert Clips | Free · $10/mo | API.market

🎬 Versatile AI Video Processing Utilities API (video-utils)

FREE

MagicAPI

PAYG

ULTRA

ELITE

MEGA

GIGA

BULK

Enhance, edit, and transform videos with fast AI-powered utilities for seamless video automation and creative workflows.