Name: DeOldify Video – AI Video Colorization | Free · $5/mo | API.market
Brand: magicapi
SKU: api-magicapi-video-colorization-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎥 Rapid Video Colorization API (DeOldify Video by arielreplicate)

## Overview
Gain the power to transform black-and-white videos into vibrant, full-color masterpieces with this rapid video colorization API. Whether you're restoring archival film footage, enhancing historical documentaries, or adding a creative twist to your personal projects, this API delivers high-fidelity colorization quickly and reliably. Simply provide a URL to your input video, and the API will return a colorized output video.

## Features
- Fast, high-resolution video colorization with minimal setup
- Flexible “render_factor” parameter to fine-tune color vibrance and quality
- Simple asynchronous workflow: submit a request, then poll for results
- Suitable for a variety of historical and creative video transformation needs

## Use Cases
1. Restoring historical videos for museums, documentaries, or vintage film enthusiasts  
2. Enhancing family archives or personal videos by bringing color to treasured memories  
3. Adding a retro effect or stylized colorization to modern video content  
4. Producing remastered footage for social media, marketing, or educational content  
5. Rapid prototyping for content creators who want to add color to black-and-white sequences  

## Visual Examples

Below is an example of input and output videos. The input black-and-white clip is a snippet from a Chaplin era film. After processing, the output clip becomes colorized, showcasing this API's capabilities.

**Input Video (Black & White Chaplin Clip):**  
![Input Video (Chaplin black & white)](https://replicate.delivery/pbxt/I9vNNmX3xjTMBVa1vq7GQIUlq8wPgJ1n0vF0dWg3tdVXYc9Y/chaplin_cut_small.mp4)

**Output Video (Colorized Chaplin Clip):**  
![Output Video (Chaplin colorized)](https://replicate.delivery/pbxt/qZEPCbqIRar4DxensmPJCNGSzqGpM83XRcNwlOPXRFlqfdVQA/tmp53dp4rcechaplin_cut_small.mp4)

## Pricing
- 1 API unit = 1 processed video.
- Checking prediction status with a GET request at /api/v1/magicapi/video-colorization-api/predictions/{id} is free of charge.
- Different pricing tiers are available depending on usage volume.

## API Documentation

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

### Authentication
Include your API key in the request header:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```
This key authenticates your requests and ensures that only authorized users can access the API.

### Asynchronous Processing
This API uses asynchronous processing. Here’s the typical workflow:
1. POST a new prediction request to /api/v1/magicapi/video-colorization-api/predictions  
2. Receive a prediction ID in the response  
3. Poll the GET /api/v1/magicapi/video-colorization-api/predictions/{id} endpoint to check the status  
4. Once the prediction is completed (status = "succeeded"), retrieve the output URL for the colorized video  

Recommended polling approach:
- Wait 1 second between status checks  
- Timeout after 600 seconds (10 minutes)  
- If the status is “failed,” handle the error accordingly  

### Endpoints

#### 1. Create a Prediction
• Method: `POST`  
• Endpoint: `/api/v1/magicapi/video-colorization-api/predictions`  
• Description: Create a new colorization prediction with your input video and optional parameters.

Example request body (JSON):
```json
{
  "input": {
    "input_video": "https://replicate.delivery/pbxt/I9vNNmX3xjTMBVa1vq7GQIUlq8wPgJ1n0vF0dWg3tdVXYc9Y/chaplin_cut_small.mp4",
    "render_factor": 21
  }
}
```

Example cURL request:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/video-colorization-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "input_video": "https://replicate.delivery/pbxt/I9vNNmX3xjTMBVa1vq7GQIUlq8wPgJ1n0vF0dWg3tdVXYc9Y/chaplin_cut_small.mp4",
      "render_factor": 21
    }
  }'
```

Example response (JSON):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "8f1189b476fcb54cfbe1d07d97b025c571a2ce4e9a7a9558640c78647576e16f",
  "status": "starting",
  "created_at": "2025-04-21T05:53:54.843Z"
}
```

#### 2. Get Prediction Status
• Method: `GET`  
• Endpoint: `/api/v1/magicapi/video-colorization-api/predictions/{id}`  
• Description: Retrieve the prediction status and results.

Example cURL request:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/video-colorization-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

Example response (JSON):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://replicate.delivery/pbxt/qZEPCbqIRar4DxensmPJCNGSzqGpM83XRcNwlOPXRFlqfdVQA/tmp53dp4rcechaplin_cut_small.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 succeeded.  
- **201 Created**: Prediction created successfully.  
- **400 Bad Request**: The request is invalid; check parameters.  
- **401 Unauthorized**: Missing or invalid API key; verification failed.  
- **403 Forbidden**: API key is valid but does not have permission for this action.  
- **404 Not Found**: The requested resource (e.g., prediction ID) was not found.  
- **429 Too Many Requests**: Rate limit exceeded; wait or upgrade your plan.  
- **500 Internal Server Error**: A server-side error occurred; try again later.  
- **503 Service Unavailable**: The service is temporarily down or overloaded.  

## Rate Limits
The API enforces rate limits based on your subscription tier. If you exceed your allocated requests per minute or daily usage, you may receive a 429 Too Many Requests error. Consult your plan or contact support if you need higher limits.

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

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

To handle errors:
- Check the returned status code and error message.  
- Rectify any parameter issues or wait if you’re rate-limited.  
- Implement retry logic for transient or recoverable errors (e.g., 503).  
- For non-recoverable errors, log the details for further investigation.  

## Implementation Guide

### Example Code

Below are some sample implementations in JavaScript, Python, and cURL. All examples illustrate how to:
1. Authenticate using your API key.  
2. Create a prediction (POST).  
3. Poll for the status (GET).  
4. Handle timeouts, retries, and errors.  

#### JavaScript (Node.js) Example

```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/video-colorization-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({ 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 a 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:
// Provide the video URL and optional render_factor
createAndWaitForPrediction({
  input_video: "https://replicate.delivery/pbxt/I9vNNmX3xjTMBVa1vq7GQIUlq8wPgJ1n0vF0dWg3tdVXYc9Y/chaplin_cut_small.mp4",
  render_factor: 21
})
  .then(outputUrl => {
    console.log("Colorized video available at:", outputUrl);
  })
  .catch(e => console.error(e));
```

#### Python Example

```python
import requests
import time

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

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-magicapi-key": API_KEY
    }
    response = requests.post(f"{BASE_URL}/predictions", headers=headers, json={"input": input_data})
    
    if response.status_code != 200 and response.status_code != 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  # seconds (10 minutes)
    POLL_INTERVAL = 1  # seconds

    headers = {"x-magicapi-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"] == "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:
result_url = create_and_wait_for_prediction({
    "input_video": "https://replicate.delivery/pbxt/I9vNNmX3xjTMBVa1vq7GQIUlq8wPgJ1n0vF0dWg3tdVXYc9Y/chaplin_cut_small.mp4",
    "render_factor": 21
})
print("Colorized video is available at:", result_url)
```

#### cURL Example

```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/video-colorization-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "input_video": "https://replicate.delivery/pbxt/I9vNNmX3xjTMBVa1vq7GQIUlq8wPgJ1n0vF0dWg3tdVXYc9Y/chaplin_cut_small.mp4",
      "render_factor": 21
    }
  }'

# Example Response:
# {
#   "id": "ufawqhfynnddngldkgtslldrkq",
#   "status": "starting",
#   "created_at": "2025-04-21T05:53:54.843Z"
# }

# Step 2: Check prediction status (repeat until status is "succeeded" or "failed")
curl -X GET "https://prod.api.market/api/v1/magicapi/video-colorization-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Use lower “render_factor” to speed up processing, especially for low-quality videos.  
- Handle predictions asynchronously in parallel, if supported by your plan.  
- Cache results if you frequently re-process the same footage.  

## FAQ
1. **What input formats are supported?**  
   Typically, standard video formats such as MP4 are supported. Provide the video URL directly.

2. **How long does colorization take?**  
   Processing time depends on video length and quality. Expect anywhere from a few seconds to a few minutes.

3. **Can I adjust how vibrant the colorization is?**  
   Yes, adjusting “render_factor” can control how vibrant or subtle the colorization appears.

4. **Can I process multiple videos at once?**  
   You can create multiple predictions concurrently, subject to your rate limits and quota.

5. **What size limits apply?**  
   The maximum video length or file size depends on your subscription tier. Contact support for details on 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.

Colorize black-and-white videos and archival footage with AI. Free 5 calls/mo, from $5/mo. Start free on API.market.

DeOldify Video – AI Video Colorization | Free · $5/mo | API.market

🎥 Rapid Video Colorization API (DeOldify Video by arielreplicate)

FREE

MagicAPI

PAYG

START

ULTRA

ELITE

MEGA

GIGA

BULK

Breathe life into black-and-white videos with blazing-fast, high-fidelity AI-powered colorization.