Name: Real-ESRGAN Video – AI Video Upscaling | Free · $5/mo | API.market
Brand: magicapi
SKU: api-magicapi-video-upscaler-high-resolution-api
Availability: InStock
Rating: 5.00 (1 reviews)
Author: API Market

Shashank Agarwal

# 🎬 High-Resolution Video Upscaler API (Real-ESRGAN Video)

## Overview
The High-Resolution Video Upscaler API (Real-ESRGAN Video) allows you to seamlessly enhance and upscale video content to ultra-high resolutions. Whether you want to transform standard-definition or lower-resolution videos into crisp full HD, 2K, or even 4K clarity, this API can handle it efficiently and quickly. The enhanced video output maintains excellent details and fidelity, making it suitable for a wide range of applications such as media production, film restoration, or social media content.

## Features
- Upscale videos to higher resolutions (FHD, 2K, or 4K) with minimal artifacts.  
- Support for multiple upscaling models (including RealESRGAN_x4plus, RealESRGAN_x4plus_anime_6B, and realesr-animevideov3).  
- Asynchronous video processing: submit a request, receive a prediction ID, and poll for status and completion.  
- Clean, high-quality results suited for professional or casual video editing needs.

## Use Cases
1. • Film restoration: Enhance old or low-quality recordings for re-releases or archiving.  
2. • Social media creators: Instantly upscale phone-camera footage to improve clarity.  
3. • E-learning content: Convert lower-resolution instructional videos to sharper outputs.  
4. • Animation and anime upscaling: Enhance clarity of anime-based content with specialized models.  
5. • Advertising and marketing: Improve resolution of promotional videos without reshooting footage.

## Examples

### Example Input Video
Below is an example of a lower-resolution video input that can be processed by this API.  
![Sample input video for upscaling](https://replicate.delivery/pbxt/JvzJwGbiuwhpRVTBdOOt3L49WAsYlBmB2yNqcyxeIlTRQ5xl/replicate-prediction-wkusuc3brp5hwd27zaymz5rgdi.mp4)

### Example Output Video
And here is the resulting upscaled output video, showing improved resolution and detail.  
![Upscaled output video](https://replicate.delivery/pbxt/PpWmE8IEmDppOZiqAOhr22BZfm7ZNNkC0Zq8iXohdKvdK19IA/tmp84vybs1breplicate-prediction-wkusuc3brp5hwd27zaymz5rgdi_out.mp4)

## Pricing
• 1 API unit = 1 video processed.  
• Checking prediction status via GET /api/v1/magicapi/video-upscaler-high-resolution-api/predictions/{id} is free.  
• Various pricing tiers are available based on volume. Contact us for more details.

## API Documentation

### Base URL
All requests should be made to:  
https://prod.api.market/api/v1/magicapi/video-upscaler-high-resolution-api

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

### Asynchronous Processing
This API runs asynchronously. The typical flow is:  
1. Create a prediction by POSTing your video input.  
2. Receive a prediction ID in the response.  
3. Poll the GET endpoint for that prediction ID to check status.  
4. When status is "succeeded," your upscaled video is ready at the URL provided in the output field.  

Processing time varies based on factors like video duration and desired resolution. Implement these best practices:  
• Wait at least 1 second between status checks.  
• Stop after 600 seconds (10 minutes) if the job has not completed.  
• If status is "succeeded," retrieve the output video.  
• If status is "failed," handle the error accordingly.

### Endpoints

#### 1. Create a Prediction (POST)
• Path: /api/v1/magicapi/video-upscaler-high-resolution-api/predictions  
• Method: POST  
• Description: Launches a new video upscaling prediction.  

Request Body (JSON):
```json
{
  "version": "c23768236472c41b7a121ee735c8073e29080c01b32907740cfada61bff75320",
  "input": {
    "video_path": "https://replicate.delivery/pbxt/JvzJwGbiuwhpRVTBdOOt3L49WAsYlBmB2yNqcyxeIlTRQ5xl/replicate-prediction-wkusuc3brp5hwd27zaymz5rgdi.mp4",
    "model": "RealESRGAN_x4plus",
    "resolution": "FHD"
  }
}
```

Sample cURL:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/video-upscaler-high-resolution-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "c23768236472c41b7a121ee735c8073e29080c01b32907740cfada61bff75320",
    "input": {
      "video_path": "https://replicate.delivery/pbxt/JvzJwGbiuwhpRVTBdOOt3L49WAsYlBmB2yNqcyxeIlTRQ5xl/replicate-prediction-wkusuc3brp5hwd27zaymz5rgdi.mp4",
      "model": "RealESRGAN_x4plus",
      "resolution": "FHD"
    }
  }'
```

Example Response (HTTP 201):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "c23768236472c41b7a121ee735c8073e29080c01b32907740cfada61bff75320",
  "status": "starting",
  "created_at": "2025-04-21T10:44:11.291Z"
}
```

#### 2. Get Prediction Status (GET)
• Path: /api/v1/magicapi/video-upscaler-high-resolution-api/predictions/{id}  
• Method: GET  
• Description: Retrieves the current status and (if completed) the output of an existing prediction.  

Sample Request:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/video-upscaler-high-resolution-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

Example Response (HTTP 200 when succeeded):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://replicate.delivery/pbxt/PpWmE8IEmDppOZiqAOhr22BZfm7ZNNkC0Zq8iXohdKvdK19IA/tmp84vybs1breplicate-prediction-wkusuc3brp5hwd27zaymz5rgdi_out.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
Below are the main HTTP status codes you may encounter and how to handle them:

- 200 OK – Request succeeded.  
- 201 Created – Prediction request accepted; a new resource was created.  
- 400 Bad Request – Malformed request or invalid parameters.  
- 401 Unauthorized – Missing or invalid API key.  
- 403 Forbidden – Valid API key but insufficient permissions.  
- 404 Not Found – Resource or prediction not found.  
- 429 Too Many Requests – Rate limit exceeded; retry after some time.  
- 500 Internal Server Error – Something went wrong on our side; try again later.  
- 503 Service Unavailable – The service is temporarily overloaded or down for maintenance.

## Rate Limits
The API enforces rate limits to ensure reliability for all users. If you exceed the current rate limit, you will receive a 429 Too Many Requests response. Implement a backoff strategy to gracefully handle these situations.

## Error Handling
When an error occurs, you’ll typically receive a JSON response with an "error" object describing the issue. For example:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'video_path' is required",
    "status": 400
  }
}
```

Common causes include missing required fields or invalid request bodies. Always check both the HTTP status code and the JSON body for more details. Retrying automatically for certain requests may be appropriate, but ensure you address the root cause of errors like invalid parameters.

## Implementation Guide

### Example Code

Below are some sample implementations in JavaScript, Python, and cURL to illustrate how to call this API, handle asynchronous processing, and manage polling for results.

#### 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/video-upscaler-high-resolution-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: "c23768236472c41b7a121ee735c8073e29080c01b32907740cfada61bff75320",
        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-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");
}

// Example usage
// (async () => {
//   const videoUrl = "https://replicate.delivery/pbxt/JvzJwGbiuwhpRVTBdOOt3L49WAsYlBmB2yNqcyxeIlTRQ5xl/replicate-prediction-wkusuc3brp5hwd27zaymz5rgdi.mp4";
//   const outputUrl = await createAndWaitForPrediction({ video_path: videoUrl, model: "RealESRGAN_x4plus", resolution: "FHD" });
//   console.log("Upscaled video URL:", outputUrl);
// })();
```

#### 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/video-upscaler-high-resolution-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-magicapi-key": API_KEY
    }
    body = {
        "version": "c23768236472c41b7a121ee735c8073e29080c01b32907740cfada61bff75320",
        "input": input_data
    }
    response = requests.post(f"{BASE_URL}/predictions", headers=headers, json=body)

    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"]

    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
    start_time = time.time()

    while time.time() - start_time < MAX_TIMEOUT:
        # Check prediction status
        headers = {"x-magicapi-key": API_KEY}
        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"]
        if status == "failed":
            raise Exception(f"Prediction failed: {prediction.get('error', 'Unknown error')}")

        time.sleep(POLL_INTERVAL)

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

# Example usage:
# video_url = "https://replicate.delivery/pbxt/JvzJwGbiuwhpRVTBdOOt3L49WAsYlBmB2yNqcyxeIlTRQ5xl/replicate-prediction-wkusuc3brp5hwd27zaymz5rgdi.mp4"
# output_url = create_and_wait_for_prediction({"video_path": video_url, "model": "RealESRGAN_x4plus", "resolution": "FHD"})
# print("Upscaled video URL:", output_url)
```

#### cURL
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/video-upscaler-high-resolution-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "c23768236472c41b7a121ee735c8073e29080c01b32907740cfada61bff75320",
    "input": {
      "video_path": "https://replicate.delivery/pbxt/JvzJwGbiuwhpRVTBdOOt3L49WAsYlBmB2yNqcyxeIlTRQ5xl/replicate-prediction-wkusuc3brp5hwd27zaymz5rgdi.mp4",
      "model": "RealESRGAN_x4plus",
      "resolution": "FHD"
    }
  }'

# Example response: {"id": "abcd1234", "status": "starting"}

# Step 2: Poll until the prediction status is "succeeded"
curl -X GET "https://prod.api.market/api/v1/magicapi/video-upscaler-high-resolution-api/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Use smaller input clips or reduce frame rate for faster processing.  
- Avoid unnecessary repeated requests—poll for status with reasonable intervals.  
- Consider caching frequently processed segments if your use case allows.

## FAQ
Q: How long does it take to upscale a video?  
A: It depends on video length, resolution, and chosen model. Smaller, shorter videos typically finish within a couple of minutes, whereas longer or higher-resolution videos can take more time.  

Q: Does the API alter the audio track?  
A: The processing focuses on video frames for resolution enhancement. Audio tracks are preserved unless otherwise noted.  

Q: Are there video format limitations?  
A: Commonly used video formats are supported. If you encounter format compatibility issues, consider converting your video to a standard format (e.g., MP4) before uploading.  

Q: How do I handle large videos?  
A: Ensure your hosting allows streaming or direct download. The upscale process is asynchronous but may take longer for large files.

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

Upscale videos to crisp 4K quality with AI. Powered by Real-ESRGAN models. Free 5 calls/mo, from $5/mo. Start free on API.market.

Real-ESRGAN Video – AI Video Upscaling | Free · $5/mo | API.market

🎬 High-Resolution Video Upscaler API (Real-ESRGAN Video)

FREE

MagicAPI

PAYG

START

ULTRA

ELITE

MEGA

GIGA

BULK

Effortlessly upscale videos to ultra-high resolutions with Real-ESRGAN, delivering crisp detail & quality fast.