Name: Image Enhance API: Deblur, Auto-Enhance, NSFW, Age & Gender
Brand: quickpod
SKU: api-quickpod-aiquick-enhance
Availability: InStock
Author: API Market

Anil Singh

# Image Enhance API

## Overview
The Image Enhance API provides a comprehensive suite of AI-powered tools for image enhancement and analysis. It offers capabilities to deblur blurry photos, automatically enhance image quality, detect potentially inappropriate (NSFW) content, and perform age and gender analysis on detected faces within images.

Designed for developers, this API simplifies the integration of advanced image processing into applications, platforms, and workflows. It's ideal for improving user-uploaded content, refining product imagery, or adding intelligent classification features. By returning processed images or structured JSON data directly, it ensures seamless integration into your existing image pipelines.

## Features
*   **Image Deblurring:** Sharpen blurry images using an adaptive unsharp mask, with adjustable strength for precise control.
*   **Auto-Enhance:** Automatically improve image contrast and brightness using CLAHE (Contrast Limited Adaptive Histogram Equalization), with an optional saturation boost.
*   **NSFW Detection:** Classify images as safe or Not Safe For Work with confidence scores, leveraging a robust, open-source ViT-based model.
*   **Age and Gender Analysis:** Detect faces within images and provide predictions for age range and gender for each detected face.
*   **Flexible Input:** Supports common image formats including JPEG, PNG, and WebP.
*   **Direct Output:** Returns processed images directly as PNG or structured JSON responses, eliminating the need for polling or complex status checks.
*   **Scalable & Efficient:** Built for high-performance and reliable image processing.

## Use Cases
*   **E-commerce & Retail:** Automatically enhance product photos uploaded by sellers or users, ensuring consistent high quality and visual appeal across online catalogs. Implement NSFW detection to moderate user-generated product reviews or comments containing images.
*   **Social Media & User-Generated Content Platforms:** Improve the clarity of user-uploaded photos, deblurring out-of-focus shots to enhance user experience. Proactively moderate content with NSFW detection to maintain a safe platform environment.
*   **Digital Asset Management & Archival:** Restore details in scanned documents, historical photos, or low-quality archival images, improving readability and visual integrity for preservation and display.
*   **Photo Editing & Mobile Applications:** Integrate advanced enhancement features directly into photo editing apps, allowing users to quickly deblur and auto-enhance images with intuitive controls.
*   **Content Moderation & Trust & Safety:** Automate the detection of explicit or inappropriate imagery for compliance and safety standards, complementing human review processes and reducing operational load.


**NSFW Classification Example (Output JSON):**
```json
{
  "nsfw": false,
  "label": "normal",
  "score": 0.9987,
  "scores": {
    "normal": 0.9987,
    "nsfw": 0.0013
  }
}
```

```json
{
  "nsfw": true,
  "label": "nsfw",
  "score": 0.9421,
  "scores": {
    "nsfw": 0.9421,
    "normal": 0.0579
  }
}
```

**Age and Gender Analysis Example (Output JSON):**
```json
{
  "face_count": 2,
  "results": [
    {
      "face_index": 0,
      "bbox": {
        "x": 45,
        "y": 30,
        "w": 120,
        "h": 120
      },
      "age": "25-32",
      "age_score": 0.72,
      "gender": "male",
      "gender_score": 0.94
    },
    {
      "face_index": 1,
      "bbox": {
        "x": 280,
        "y": 25,
        "w": 115,
        "h": 115
      },
      "age": "22-28",
      "age_score": 0.68,
      "gender": "female",
      "gender_score": 0.91
    }
  ]
}
```


## API Documentation

### Base URL
All API requests should be made to: `https://prod.api.market/api/v1/quickpod/aiquick-enhance`

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

### Endpoints

#### Health Check
Checks the service's operational status.

**GET `/health`**

*   **Summary:** Service health check
*   **Tags:** Health
*   **Parameters:**
    *   `x-api-market-key` (Header, Required): Your API.market API Key.
*   **Responses:**
    *   `200 OK`:
        *   **Description:** Healthy
        *   **Content:** `application/json`
            ```json
            {
              "ok": true,
              "service": "enhance-api"
            }
            ```

**cURL Example:**
```bash
curl -X GET "https://prod.api.market/api/v1/quickpod/aiquick-enhance/health" \
     -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

#### Sharpen Blurry Image
Applies unsharp masking to sharpen a blurry image.

**POST `/v1/image/deblur`**

*   **Summary:** Sharpen a blurry image using adaptive unsharp mask
*   **Description:** Applies unsharp masking by subtracting a Gaussian-blurred version from the original. Returns a PNG regardless of input format. Input file is deleted after processing.
*   **Tags:** Enhancement
*   **Parameters:**
    *   `x-api-market-key` (Header, Required): Your API.market API Key.
*   **Request Body (`multipart/form-data`):**
    *   `file` (Required, binary): Image file (JPEG/PNG/WebP, max 20 MB).
    *   `strength` (Optional, number): Sharpening strength. Default: `1.5` (moderate). Min: `0.1`, Max: `5`.
*   **Responses:**
    *   `200 OK`:
        *   **Description:** Sharpened PNG image
        *   **Headers:** `X-Strength` (string)
        *   **Content:** `image/png` (binary data)
    *   `413`: File exceeds 20 MB limit
    *   `422`: Invalid image format

**cURL Example:**
```bash
curl -X POST "https://prod.api.market/api/v1/quickpod/aiquick-enhance/v1/image/deblur" \
     -H "x-api-market-key: YOUR_API_MARKET_KEY" \
     -F "file=@/path/to/your/image.jpg" \
     -F "strength=3.0" \
     --output "deblurred_image.png"
```

#### Auto-Enhance Image
Automatically enhances contrast and brightness using CLAHE.

**POST `/v1/image/auto-enhance`**

*   **Summary:** Auto-enhance contrast and brightness using CLAHE with saturation boost
*   **Description:** Applies Contrast Limited Adaptive Histogram Equalization (CLAHE) on the L channel in LAB colour space for natural-looking contrast enhancement, then optionally boosts saturation in HSV space.
*   **Tags:** Enhancement
*   **Parameters:**
    *   `x-api-market-key` (Header, Required): Your API.market API Key.
*   **Request Body (`multipart/form-data`):**
    *   `file` (Required, binary): Image file (max 20 MB).
    *   `clip_limit` (Optional, number): CLAHE clip limit. Higher values increase local contrast. Default: `2`. Min: `0.5`, Max: `10`.
    *   `saturation` (Optional, number): Saturation multiplier. `1.0` = no change, `1.5` = vivid. Default: `1.2`. Min: `0.5`, Max: `3`.
*   **Responses:**
    *   `200 OK`:
        *   **Description:** Enhanced PNG image
        *   **Headers:** `X-Clip-Limit` (string), `X-Saturation` (string)
        *   **Content:** `image/png` (binary data)
    *   `413`: File exceeds 20 MB limit
    *   `422`: Invalid image format

**cURL Example:**
```bash
curl -X POST "https://prod.api.market/api/v1/quickpod/aiquick-enhance/v1/image/auto-enhance" \
     -H "x-api-market-key: YOUR_API_MARKET_KEY" \
     -F "file=@/path/to/your/image.png" \
     -F "clip_limit=3" \
     -F "saturation=1.5" \
     --output "enhanced_image.png"
```

#### NSFW Classification
Classifies an image as safe or NSFW.

**POST `/v1/image/nsfw`**

*   **Summary:** Classify an image as safe or NSFW with confidence score
*   **Description:** Uses `Falconsai/nsfw_image_detection` (MIT, ViT-based) to classify the image. Returns a boolean `nsfw` flag, the top label, score, and a score breakdown.
*   **Tags:** Classification
*   **Parameters:**
    *   `x-api-market-key` (Header, Required): Your API.market API Key.
*   **Request Body (`multipart/form-data`):**
    *   `file` (Required, binary): Image file (max 20 MB).
*   **Responses:**
    *   `200 OK`:
        *   **Description:** NSFW classification result
        *   **Content:** `application/json`
            ```json
            {
              "nsfw": false,
              "label": "normal",
              "score": 0.9987,
              "scores": {
                "normal": 0.9987,
                "nsfw": 0.0013
              }
            }
            ```
            or
            ```json
            {
              "nsfw": true,
              "label": "nsfw",
              "score": 0.9421,
              "scores": {
                "nsfw": 0.9421,
                "normal": 0.0579
              }
            }
            ```
    *   `413`: File exceeds 20 MB limit
    *   `422`: Invalid image format

**cURL Example:**
```bash
curl -X POST "https://prod.api.market/api/v1/quickpod/aiquick-enhance/v1/image/nsfw" \
     -H "x-api-market-key: YOUR_API_MARKET_KEY" \
     -F "file=@/path/to/your/image.jpeg"
```

#### Age and Gender Analysis
Detects faces and predicts age range and gender.

**POST `/v1/image/age-gender`**

*   **Summary:** Detect faces and return age range and gender for each detected face
*   **Description:** Uses OpenCV Haar cascades to detect faces, then runs each face crop through `nateraw/vit-age-classifier` (Apache-2.0) for age range prediction and `rizvandwiki/gender-classification-2` (MIT) for gender classification. If no face is detected, runs on the full image.
*   **Tags:** Classification
*   **Parameters:**
    *   `x-api-market-key` (Header, Required): Your API.market API Key.
*   **Request Body (`multipart/form-data`):**
    *   `file` (Required, binary): Image file (max 20 MB).
*   **Responses:**
    *   `200 OK`:
        *   **Description:** Age and gender per detected face
        *   **Content:** `application/json`
            ```json
            {
              "face_count": 2,
              "results": [
                {
                  "face_index": 0,
                  "bbox": { "x": 45, "y": 30, "w": 120, "h": 120 },
                  "age": "25-32",
                  "age_score": 0.72,
                  "gender": "male",
                  "gender_score": 0.94
                },
                {
                  "face_index": 1,
                  "bbox": { "x": 280, "y": 25, "w": 115, "h": 115 },
                  "age": "22-28",
                  "age_score": 0.68,
                  "gender": "female",
                  "gender_score": 0.91
                }
              ]
            }
            ```
    *   `413`: File exceeds 20 MB limit
    *   `422`: Invalid image format

**cURL Example:**
```bash
curl -X POST "https://prod.api.market/api/v1/quickpod/aiquick-enhance/v1/image/age-gender" \
     -H "x-api-market-key: YOUR_API_MARKET_KEY" \
     -F "file=@/path/to/your/image_with_faces.jpg"
```

## Status Codes
This API uses standard HTTP status codes to indicate the success or failure of a request.

*   **200 OK**: The request was successful, and the response body contains the requested data (e.g., processed image or JSON result).
*   **400 Bad Request**: The request was malformed, or required parameters were missing or invalid. Review your request body and parameters.
    *   *Example:* Sending a JSON body to an endpoint expecting `multipart/form-data`.
*   **401 Unauthorized**: Authentication failed because the `x-api-market-key` header was missing or invalid. Ensure you provide a valid API key.
*   **403 Forbidden**: Your API key is valid, but you do not have sufficient permissions to access the requested resource or perform the action.
*   **404 Not Found**: The requested API endpoint or resource does not exist. Check the URL path for typos.
*   **413 Payload Too Large**: The uploaded image file exceeds the maximum allowed size (20 MB). Reduce the file size and retry.
*   **422 Unprocessable Entity**: The request was well-formed but could not be processed due to semantic errors, such as an invalid image format.
*   **429 Too Many Requests**: You have exceeded the API rate limit. Implement a back-off and retry strategy.
*   **500 Internal Server Error**: An unexpected error occurred on the server. This is typically a transient issue; you may retry the request.
*   **503 Service Unavailable**: The service is temporarily unable to handle the request, often due to maintenance or overload. Try again after a short delay.

## Rate Limits
To ensure fair usage and service stability, API requests are subject to rate limits. If you exceed the allocated number of requests within a given timeframe, you will receive a `429 Too Many Requests` HTTP status code.

It is recommended to implement exponential back-off in your client to gracefully handle rate limit errors and retry requests. If you anticipate high-volume usage, please contact support for potential adjustments to your rate limits.

## Error Handling
Effective error handling is crucial for building robust applications. This section provides guidance on how to interpret and respond to errors from the Image Enhance API.

**Interpreting Error Responses:**
When an error occurs (indicated by a 4xx or 5xx status code), the API will typically return a JSON object in the response body with details about the error.

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'file' is required.",
    "status": 400
  }
}
```
*   `error.code`: A programmatic code indicating the type of error.
*   `error.message`: A human-readable description of the error, providing specific details.
*   `error.status`: The HTTP status code of the response.

**Common Errors and Resolution:**
*   **`400 Bad Request`**:
    *   **Issue:** Missing required fields (e.g., `file` parameter), invalid `strength` or `clip_limit` values, or incorrect `Content-Type` header (e.g., sending JSON instead of `multipart/form-data`).
    *   **Resolution:** Verify your request body, parameters, and headers against the endpoint documentation.
*   **`401 Unauthorized`**:
    *   **Issue:** Incorrect or missing `x-api-market-key` header.
    *   **Resolution:** Ensure your API key is correctly included in the `x-api-market-key` header.
*   **`413 Payload Too Large`**:
    *   **Issue:** The image file you are uploading exceeds the 20 MB limit.
    *   **Resolution:** Resize or compress your image to be under 20 MB before sending.
*   **`422 Unprocessable Entity`**:
    *   **Issue:** The uploaded file is not a valid image format (e.g., a text file with a `.jpg` extension) or the image data is corrupted.
    *   **Resolution:** Ensure you are sending valid JPEG, PNG, or WebP image files.
*   **`429 Too Many Requests`**:
    *   **Issue:** You've sent too many requests in a short period.
    *   **Resolution:** Pause your requests and implement an exponential back-off strategy before retrying.
*   **`500 Internal Server Error` / `503 Service Unavailable`**:
    *   **Issue:** Server-side issues.
    *   **Resolution:** These are usually transient. Implement a retry strategy with a short delay. If the problem persists, contact support.

**Recommended Retry Strategies:**
For transient errors (`429`, `500`, `503`), implement an exponential back-off strategy:
1.  Wait for an initial short delay (e.g., 1 second).
2.  If the retry fails, double the delay for the next attempt (e.g., 2s, 4s, 8s).
3.  Set a maximum number of retries (e.g., 3-5 times) and a maximum total wait time to prevent indefinite blocking.



#### cURL (Command Line)

This example shows how to send an image for deblurring and save the output. For JSON responses, omit the `--output` part.

```bash
# Example for Deblurring an image
curl -X POST "https://prod.api.market/api/v1/quickpod/aiquick-enhance/v1/image/deblur" \
     -H "x-api-market-key: YOUR_API_MARKET_KEY" \
     -F "file=@/path/to/your/input.jpg" \
     -F "strength=2.5" \
     --output "deblurred_output.png"

# Example for NSFW classification (JSON output to console)
curl -X POST "https://prod.api.market/api/v1/quickpod/aiquick-enhance/v1/image/nsfw" \
     -H "x-api-market-key: YOUR_API_MARKET_KEY" \
     -F "file=@/path/to/your/input.jpeg"
```

## Performance Optimization
To get the best performance and manage costs when using the Image Enhance API:

*   **Image File Sizes:** While the API supports up to 20MB images, processing smaller images (e.g., under 5MB for typical web use) will generally result in faster response times and potentially lower data transfer costs.
*   **Image Format:** Use efficient image formats where possible. While the API handles common formats, consider optimizing your input images. The API output for enhancement endpoints is always PNG for quality, but this can be converted client-side if a different format is needed.
*   **Parallel Processing:** If your application requires processing multiple images, you can issue multiple API requests in parallel. Be mindful of rate limits when doing so.
*   **Client-Side Optimization:** Implement client-side validation for image formats and sizes before sending them to the API to reduce unnecessary requests and bandwidth usage.
*   **Error Handling and Retries:** Implement robust error handling with exponential back-off for transient errors (`429`, `5xx`). This ensures your application remains resilient and doesn't get stuck in failure states.

## FAQ

**Q: What image formats are supported for input?**

A: The API primarily supports JPEG, PNG, and WebP formats.

**Q: What is the maximum file size for an image?**

A: The maximum allowed file size for an input image is 20 MB. Requests with larger files will result in a `413 Payload Too Large` error.

**Q: What is the output format for enhanced images?**

A: The `deblur` and `auto-enhance` endpoints always return processed images in PNG format, regardless of the input format. Classification endpoints (`nsfw`, `age-gender`) return JSON data.

**Q: How accurate are the NSFW detection and age/gender classification models?**

A: The models used are open-source and widely recognized, providing high accuracy for general-purpose use. However, as with any AI model, performance can vary based on image quality, context, and racial/gender representation in the training data. Continuous evaluation and testing with your specific use case data are recommended.

**Q: Can I process multiple images in a single API request?**

A: No, each API request is designed to process a single image file. For multiple images, you will need to make separate requests for each image. You can run these requests in parallel from your application.

**Q: Is there a free trial available?**

A: Please check the API.market platform for details on free trials or introductory offers.

## 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@magicapi.com.

Transform and analyze images with the Image Enhance API. Deblur, auto-enhance, classify NSFW content, and detect age/gender from photos for robust image process

Image Enhance API: Deblur, Auto-Enhance, NSFW, Age & Gender

Free