Name: Google Upscaler – AI Image Enhancement | $0.03/call | API.market
Brand: magicapi
SKU: api-magicapi-high-quality-image-upscaler-google-upscaler
Availability: InStock
Author: API Market

Shashank Agarwal

# 🔍 High-Resolution Image Upscaler API (google/upscaler)

## Overview
The 🔍 High-Resolution Image Upscaler API enables developers to upscale images by 2x or 4x, preserving exceptional detail and minimizing artifacts. This API leverages state-of-the-art AI to enhance image quality, making it ideal for various applications in different industries.

## Features
- **Upscaling Options**: Enlarge images by 2x or 4x.
- **Detail Preservation**: Retain fine details in upscaled images.
- **Artifact Reduction**: Reduce common upscaling artifacts.
- **Custom Compression Quality**: Specify the output image compression quality (1-100).
- **Asynchronous Processing**: Handle large images effectively with asynchronous prediction requests.

## Use Cases
- **E-commerce**: Enhance product images for better presentation and increased sales.
- **Digital Media**: Improve the quality of images used in digital marketing materials.
- **Photography**: Upscale and enhance resolution of photos for printing.
- **Real Estate**: Enhance property images for online listings.
- **Medical Imaging**: Improve the clarity of medical images for better diagnostics.

## Visual Examples
### Input Image
![Input Image](https://blog.api.market/wp-content/uploads/2026/01/image-upscaler-api-market.png)
*Input image to be upscaled.*

### Output Image (2x Upscaled)
![Output Image 2x](https://blog.api.market/wp-content/uploads/2026/01/output-upscaler-api-market-scaled.png)
*Example of a 2x upscaled image.*

## Pricing
- **Pay As You Go (PAYG)**: Only pay for the images you process.
- **API Unit Usage**: 1 API unit equals 1 image processed.
- **Free Status Checks**: GET requests to check prediction status are free and do not count toward API unit usage.
- **No Subscription Fees**: Simple per-call pricing with no monthly subscription fees or usage limits.

## API Documentation

### Base URL
All API requests should be made to:
```
https://prod.api.market/api/v1/magicapi/high-quality-image-upscaler-google-upscaler
```

### Authentication
Authentication is handled via API key. Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API uses asynchronous processing for predictions. The typical flow is:
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.

**Polling Recommendations**:
- Polling interval: 1 second between status checks.
- Maximum timeout: 600 seconds (10 minutes).
- Continue polling while status is "starting" or "processing".
- Handle result when status becomes "succeeded".
- Handle errors when status becomes "failed" or timeout is reached.

### Endpoints

#### Create Prediction
Create a new prediction with the provided input image and parameters.

**Endpoint**: 
```
POST /api/v1/magicapi/high-quality-image-upscaler-google-upscaler/predictions
```

**Request Example**:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/high-quality-image-upscaler-google-upscaler/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "1034a2d9bc09f17cba2c5fb6c5e91d23af2f9311684f75c8deda076c6d05f1a9",
    "input": {
      "image": "https://example.com/image.jpg",
      "upscale_factor": "x4",
      "compression_quality": 80
    }
  }'
```

**Response Example**:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "1034a2d9bc09f17cba2c5fb6c5e91d23af2f9311684f75c8deda076c6d05f1a9",
  "status": "starting",
  "created_at": "2026-01-29T08:32:46.465Z"
}
```

#### Check Prediction Status
Get the status and results of a prediction.

**Endpoint**: 
```
GET /api/v1/magicapi/high-quality-image-upscaler-google-upscaler/predictions/{id}
```

**Request Example**:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/high-quality-image-upscaler-google-upscaler/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Response Example**:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/01/output-upscaler-api-market-scaled.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"
}
```

## Status Codes
- **200 OK**: Request successful.
- **201 Created**: Resource 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.
- **429 Too Many Requests**: Rate limit exceeded.
- **500 Internal Server Error**: Server-side error.
- **503 Service Unavailable**: Service temporarily unavailable.

## Rate Limits
API.market enforces rate limits to ensure fair use for all users:
- Maximum of 60 requests per minute.
- Exceeding the limit will result in a 429 Too Many Requests error.
- Implement retry logic with exponential backoff to handle rate limit errors.

## Error Handling
- **Interpreting Error Responses**: Error responses contain an `error` object with `code`, `message`, and `status` fields. 
- **Common Errors**:
  - Invalid parameter: Correct the request parameters.
  - Invalid API key: Ensure the API key is correctly provided.
  - Rate limit exceeded: Implement retry logic.

**Error Response Example**:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```

## Implementation Guide

### JavaScript Example
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/high-quality-image-upscaler-google-upscaler";

async function createAndWaitForPrediction(inputData) {
  try {
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({ version: "1034a2d9bc09f17cba2c5fb6c5e91d23af2f9311684f75c8deda076c6d05f1a9", input: inputData })
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    
    const prediction = await response.json();
    const predictionId = prediction.id;
    
    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) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-api-market-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 Example
```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/high-quality-image-upscaler-google-upscaler"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "1034a2d9bc09f17cba2c5fb6c5e91d23af2f9311684f75c8deda076c6d05f1a9", "input": input_data}
    )
    
    if response.status_code != 200:
        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
    
    headers = {"x-api-market-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")
```

### Performance Optimization
- **Optimize Image Quality**: Use lower `compression_quality` values for faster processing times.
- **Efficient Polling**: Implement a delay interval between status checks to avoid excessive requests.
- **Error Handling**: Set up robust error handling to manage rate limits and server errors efficiently.

## FAQ
**Q: What is the maximum image size that can be upscaled?**
A: The API handles images up to 10MB in size.

**Q: How long does it take to process an image?**
A: Processing time varies based on image complexity. Average times are 10-60 seconds.

**Q: Can I cancel a prediction?**
A: Yes, predictions can be canceled by sending a request to the cancel endpoint with the prediction ID.

## 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 images by 2x or 4x with exceptional detail and reduced artifacts. Enhance resolution for e-commerce. From $0.03/call. Try it free on API.market.