Name: Photo Restoration – Fix Old Photos | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-restore-old-photos-ai
Availability: InStock
Rating: 5.00 (1 reviews)
Author: API Market

Shashank Agarwal

# 🖼️ Old Photo Restoration API (Bringing Old Photos Back to Life)

## Overview
The Old Photo Restoration API allows you to transform faded, damaged, or worn-out photographs into vibrant, clean, and lifelike images using advanced AI techniques. Whether you’re dealing with scratches, low resolution, or discoloration, this API helps recover lost details and restore photos to a vivid state in just a few seconds.

## Features
- Automated image restoration to fix faded colors, discoloration, and low resolution  
- Advanced AI scratch detection and repair  
- Option to process high-resolution (HR) images for improved clarity and detail  
- Easy integration for a wide range of use cases and platforms  
- Asynchronous processing for efficient, queue-based handling of photo restorations  

## Use Cases
1. Historical Preservation: Revitalize old family photos or historical archives.  
2. Photo Editing Services: Offer instant photo repair features to your users.  
3. Museum and Library Digitization: Automatically restore large volumes of archived images.  
4. Genealogical Research: Improve clarity of historical and family records.  
5. Media & Marketing Improvements: Enhance brand visuals by restoring vintage photos for nostalgic campaigns.

## Visual Examples

Below are sample images that illustrate the usage of the Old Photo Restoration API:

### Sample Input
This example shows a faded, low-resolution photo that requires color enhancement and scratch removal.

![Sample input image of a faded old photograph](https://blog.api.market/wp-content/uploads/2026/04/photo-restore-api-market.png)

### Sample Output
Here is the resulting image after processing, displaying improved color balance, enhanced clarity, and scratch removal.

![Sample output image showing the restored photograph](https://blog.api.market/wp-content/uploads/2026/04/output-photo-restore-api-market.png)

## Pricing
• 1 API unit equals 1 image processed.  
• GET requests to check prediction status (GET /api/v1/magicapi/restore-old-photos-ai/predictions/{id}) are free and do not count toward API usage.  
• Multiple pricing tiers are available, with discounts for higher-volume usage.

## API Documentation

### Base URL
All requests must be sent to:  
```
https://prod.api.market/api/v1/magicapi/restore-old-photos-ai
```

### Authentication
Include your API key in the header of every request:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```
Keep your API key secret—anyone with your key can make requests on your behalf.

### Asynchronous Processing
This API processes images asynchronously. The typical flow is:

1. Send a POST request to create a prediction (i.e., process a photo).  
2. Receive a prediction ID in the response.  
3. Poll the GET endpoint with the provided prediction ID to check the status of your request.  
4. When the status becomes "succeeded," your restored image is ready.  

Allow up to 10 minutes (600 seconds) for challenging or high-resolution images. During that time, continue polling at 1-second intervals until completion.

### Endpoints

#### 1) Create a Prediction
• Endpoint:  
  ```
  POST /api/v1/magicapi/restore-old-photos-ai/predictions
  ```

• Description:  
  Submits a new photo for restoration. Returns a unique prediction ID.

• Request Body (JSON):
```json
{
  "input": {
    "image": "https://example.com/image.jpg",
    "HR": false,
    "with_scratch": false
  }
}
```
Notes:  
- "image" (required): URL to the input photo.  
- "HR": Set to true if the input image is high resolution.  
- "with_scratch": Set to true if the photo has noticeable scratches or physical damage.

• Example (cURL):
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/restore-old-photos-ai/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "image": "https://example.com/image.jpg",
      "HR": false,
      "with_scratch": false
    }
  }'
```

• Response (JSON):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "c75db81db6cbd809d93cc3b7e7a088a351a3349c9fa02b6d393e35e0d51ba799",
  "status": "starting",
  "created_at": "2025-04-23T20:02:00.842Z"
}
```
- "id": Unique identifier to poll for status updates.  
- "status" can be "starting," "processing," "succeeded," or "failed."  

#### 2) Get Prediction Status
• Endpoint:  
  ```
  GET /api/v1/magicapi/restore-old-photos-ai/predictions/{id}
  ```

• Description:  
  Retrieve the status of a previously created prediction. If "status" is "succeeded," the "output" field will contain the restored image URL(s).

• Example (cURL):
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/restore-old-photos-ai/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

• Response (JSON):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": [
    {
      "file": "https://blog.api.market/wp-content/uploads/2026/04/output-photo-restore-api-market.png"
    }
  ],
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```
- "output": An array of restored image URLs.  
- "status": If "succeeded," you can use the returned image(s). If "failed," check "error" for more details.

## Status Codes
• 200 OK: Successful request.  
• 201 Created: A resource (prediction) was successfully created.  
• 400 Bad Request: Invalid input or malformed request.  
• 401 Unauthorized: API key is missing or invalid.  
• 403 Forbidden: Valid API key but not enough permissions.  
• 404 Not Found: Could not find the requested resource (e.g., invalid prediction ID).  
• 429 Too Many Requests: Rate limit exceeded.  
• 500 Internal Server Error: A service-side error occurred.  
• 503 Service Unavailable: The service is temporarily overloaded or down for maintenance.

## Rate Limits
This API implements a rate-limiting system to prevent excessive usage. If you exceed your plan’s request limits, you’ll receive a 429 Too Many Requests response. Handle 429 responses by waiting briefly before retrying. For higher volumes, you can upgrade your plan.

## Error Handling
When an error occurs, the API responds with a JSON object containing an "error" field describing the issue.

Example of a 400 Bad Request error:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```
Best practices:
- Check the error code to determine the cause (e.g., missing fields, invalid URLs).
- Implement retries for transient errors (e.g., 5xx).
- Correct invalid parameters before resubmitting.

## Implementation Guide

### JavaScript Example
Below is a complete example using async/await. It creates a prediction, polls for results (once per second), and times out after 10 minutes.

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

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

  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 final output
      return prediction.output;
    }
    
    if (prediction.status === "failed") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }
    
    // Wait before next poll
    await delay(POLL_INTERVAL);
  }
  
  throw new Error("Prediction timed out after 10 minutes");
}
```

### Python Example
A Python implementation with the requests library:

```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/restore-old-photos-ai"

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
    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 Example

```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/restore-old-photos-ai/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "image": "https://example.com/image.jpg"
    }
  }'

# The response will contain a prediction ID:
# {
#   "id": "abcd1234",
#   "status": "starting",
#   ...
# }

# Step 2: Poll for status (repeat until status is "succeeded")
curl -X GET "https://prod.api.market/api/v1/magicapi/restore-old-photos-ai/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- For batch processing, queue multiple images in parallel but don’t exceed rate limits.  
- Use high-resolution images (set "HR": true) only when necessary to reduce processing time and API costs.  
- Cache or store results if you plan on reusing the same image input frequently.

## FAQ
1. Can I submit multiple images at once?  
   - Currently, each request processes only one image at a time.  
2. How long does the average prediction take?  
   - Typically a few seconds, but it can take up to 10 minutes for highly detailed or large images.  
3. Will existing color artifacts be removed?  
   - Yes. The API uses advanced reconstruction to remove artifacts, scratches, and noise.

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

Automatically restore faded, damaged, or blurry old photos with AI. Fix scratches, enhance faces, and repair discoloration. Try it free on API.market.