Name: Ghostface AI – Upscale GIF to Video | Free · $5/mo | API.market
Brand: magicapi
SKU: api-magicapi-gif-to-high-res-video-upscaler
Availability: InStock
Rating: 5.00 (1 reviews)
Author: API Market

Shashank Agarwal

# 🚀 High-Resolution GIF-to-Video Upscaler API (ghostface-ai)

## Overview
The High-Resolution GIF-to-Video Upscaler API instantly transforms any low-resolution GIF into a crisp, high-resolution MP4 video. Simply provide a link to your GIF, and the API returns a beautifully upscaled result suitable for professional presentations, social media, marketing materials, or anywhere else you need polished outputs.

## Features
- Converts GIFs to MP4 format for broader compatibility and improved quality.  
- Upscales low-resolution GIFs, preserving details and enhancing clarity.  
- Fast, asynchronous processing for quickly handling multiple GIFs.  
- Easy integration with any tech stack through simple HTTP endpoints.  
- Automatic handling of color, frames, and resolution to produce professional results.

## Use Cases
1. **Social Media Marketers**: Convert and upscale promotional GIFs or memes into HD videos that stand out on platforms like Facebook, Instagram, or Twitter.  
2. **E-Learning Platforms**: Enhance instructional GIF animations into high-resolution videos for smoother playback and professional course content.  
3. **Advertising & Creative Agencies**: Turn low-res demo animations into clear product videos for client presentations.  
4. **Game Developers**: Showcase gameplay GIFs in trailers or highlight reels by upscaling them for YouTube or other video platforms.  
5. **Content Creators & Influencers**: Produce crisp, attention-grabbing video content from existing GIFs to keep feeds engaging and high quality.

## Visual Examples

Below is an example of an input GIF and a corresponding output video that demonstrates what the API can do.

### Input GIF
![Terminator GIF Input](https://replicate.delivery/pbxt/MpG2oO0L90Y3SgJtJ3c5JuDrGFBQzXWk4NyZw9atQJf04Aaz/input_terminator.gif)

### Output Video
![Upscaled Video Output](https://replicate.delivery/czjl/uE4Q8ooop9oQBxjQwTWwKYu9dQ3fl4KrlZG8KeCwgBdw5fJpA/result.mp4)

When upscaling this sample GIF, the output shows improved resolution and clarity in MP4 format.

## Pricing
- 1 API unit equals 1 GIF processed.  
- GET requests to check prediction status (GET /api/v1/magicapi/gif-to-high-res-video-upscaler/predictions/{id}) are free and do not count toward API unit usage.  
- Different pricing tiers are available based on your usage volume, ensuring you can scale up or down as needed.

## API Documentation

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

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

### Asynchronous Processing
This API processes requests asynchronously:
1. Submit a prediction request (POST) with your GIF.  
2. Receive a prediction ID from the API.  
3. Poll the GET endpoint using the ID to check the status.  
4. Once the status is "succeeded," retrieve your high-resolution MP4 video from the `output` field.

Implementation details for handling async predictions:
- Use a polling interval of 1 second between status checks.  
- Implement a maximum timeout of 600 seconds (10 minutes).  
- Continue polling while the `status` is "starting" or "processing."  
- If the status becomes "failed" or you reach your timeout, handle the error gracefully.

### Endpoints

#### 1) Create a Prediction
• Method: `POST`  
• Endpoint: `/api/v1/magicapi/gif-to-high-res-video-upscaler/predictions`  
• Description: Submits a new GIF upscaling request.

Example Request (cURL):
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/gif-to-high-res-video-upscaler/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "input_gif": "https://replicate.delivery/pbxt/MpG2oO0L90Y3SgJtJ3c5JuDrGFBQzXWk4NyZw9atQJf04Aaz/input_terminator.gif"
    }
  }'
```

Example Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "460be71a966c1546473a73d20e91b46a540c1251232ef4ac984417c20763feaa",
  "status": "starting",
  "created_at": "2025-05-18T08:21:03.223Z"
}
```

#### 2) Get Prediction Status and Results
• Method: `GET`  
• Endpoint: `/api/v1/magicapi/gif-to-high-res-video-upscaler/predictions/{id}`  
• Description: Retrieves the status and result of an existing GIF upscaling request.

Example Request (cURL):
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/gif-to-high-res-video-upscaler/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

Example Response (200 OK when succeeded):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://replicate.delivery/czjl/uE4Q8ooop9oQBxjQwTWwKYu9dQ3fl4KrlZG8KeCwgBdw5fJpA/result.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 was successful.  
- **201 Created**: A new resource (prediction) was created successfully.  
- **400 Bad Request**: Invalid input parameters or a malformed request.  
- **401 Unauthorized**: Missing or invalid API key.  
- **403 Forbidden**: Valid API key, but insufficient permissions to access the resource.  
- **404 Not Found**: The requested resource does not exist.  
- **429 Too Many Requests**: You have exceeded the allowed rate limit.  
- **500 Internal Server Error**: A server-side error occurred.  
- **503 Service Unavailable**: The service is temporarily unavailable.

## Rate Limits
Depending on your plan, you may have limits on:
- Number of requests per minute/hour/day.  
- Concurrency of active predictions.  

If you exceed these limits, you may receive a 429 Too Many Requests response. In this case, wait for a short period before retrying or upgrade your plan if you need additional capacity.

## Error Handling
When an error occurs, the API responds with a JSON object indicating the problem:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'input_gif' is required",
    "status": 400
  }
}
```
Best practices:
- Check the error code and message to identify the cause.  
- Fix any invalid or missing parameters before retrying.  
- Implement retries for occasional transient errors, but with a suitable back-off strategy.  
- If you repeatedly encounter errors, ensure that your API usage and request parameters align with the required specifications.

## Implementation Guide

Below are sample code snippets in JavaScript, Python, and cURL illustrating how to create and poll predictions asynchronously.

### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/gif-to-high-res-video-upscaler";

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 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");
}
```

#### Python
```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/gif-to-high-res-video-upscaler"

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  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second
    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")
```

#### cURL
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/gif-to-high-res-video-upscaler/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "input_gif": "https://replicate.delivery/pbxt/MpG2oO0L90Y3SgJtJ3c5JuDrGFBQzXWk4NyZw9atQJf04Aaz/input_terminator.gif"
    }
  }'

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

# Step 2: Check prediction status (replace abcd1234 with your actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/gif-to-high-res-video-upscaler/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"

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

### Performance Optimization
- Only send necessary GIFs and avoid resubmitting the same resource multiple times.  
- Use efficient polling intervals (1 second) to balance timely updates and minimal network traffic.  
- Handle errors gracefully and implement retry logic with back-off if you encounter rate limits.

## FAQ
1. **Is there a size limit for GIFs?**  
   Yes. Check your plan details for maximum file size. Larger files will require more processing time.  
2. **How long does processing normally take?**  
   Typically within seconds, but it can vary depending on the GIF size and frame count.  
3. **Which output format is supported?**  
   The API outputs an MP4 file.  
4. **Can I poll more frequently than 1 second?**  
   We recommend a 1-second interval to reduce redundant requests and avoid rate limits.  
5. **What happens if my request times out?**  
   Your code should handle timeouts by stopping the polling process and possibly retrying or informing the user of a failed operation.

## 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 low-res GIFs to high-resolution MP4 videos in seconds. Free 50 calls/mo, from $5/mo. Start free on API.market.

Ghostface AI – Upscale GIF to Video | Free · $5/mo | API.market

🚀 High-Resolution GIF-to-Video Upscaler API (ghostface-ai)

FREE

MagicAPI

PAYG

START

ULTRA

ELITE

MEGA

GIGA

BULK

The API does a fantastic job of turning low-res GIFs into clean, high-quality MP4 videos. Super easy to use and perfect for anyone who wants polished results without extra effort.
