Name: Rembg Enhance – Accurate Image Cutouts | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-enhanced-background-removal-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 🪄 Enhanced Background Removal API (smoretalk/rembg-enhance)

## Overview
The Enhanced Background Removal API offers advanced background removal capabilities for images, producing crisp and accurate cutouts. By leveraging sophisticated matting techniques, this API is perfect for scenarios that require high-quality, detail-oriented extractions, such as e-commerce product photography, design mockups, and more.

![Example Input Image (AI-generated flamel artwork)](https://blog.api.market/wp-content/uploads/2026/04/kiwi-api-market.png)

Above is a sample input image showcasing a stylized 3D Icon. After processing, the background is removed to produce a clean, transparent cutout for versatile use.

![Example Output Image (Background removed)](https://blog.api.market/wp-content/uploads/2026/04/kiwi-output.png)

## Features
- Advanced matting algorithm for crisp edges and minimal artifacts  
- High-fidelity background removal for complex shapes and fine details  
- Fast and efficient processing workflow, scalable for large image batches  
- Suitable for diverse industries including retail, design, real estate, and manufacturing  
- Straightforward asynchronous API for seamless integration into any pipeline  

## Use Cases

1. E-commerce Product Listings  
   Remove backgrounds from product images to create clean, professional listings without distracting elements.  

2. Marketing and Advertising  
   Produce eye-catching promotional materials by isolating subjects and integrating them into creative campaigns.  

3. Real Estate Virtual Staging  
   Swap out backgrounds or composite images quickly to enhance property marketing photos.  

4. Creative Design and Collateral  
   Extract subjects for brand collaterals, brochures, and creative projects with minimal manual editing.  

5. Photography and Digital Art  
   Streamline post-processing work for photographers and digital artists who need to isolate subjects for composition.  

## Visual Examples

Below are the same examples included above for clarity. The first image is the original input, and the second image is the output with the background removed:

![Original Input](https://blog.api.market/wp-content/uploads/2026/04/kiwi-api-market.png)  
![Processed Output](https://blog.api.market/wp-content/uploads/2026/04/kiwi-output.png)

## Pricing
• 1 API unit = 1 image processed  
• GET requests to check prediction status (GET /api/v1/magicapi/enhanced-background-removal-api/predictions/{id}) are free and do not count toward API unit usage  
• Different pricing tiers are available based on usage volume. Contact us to learn more about potential discounts for high-volume use.

## API Documentation

### Base URL
All requests should be made to:  
https://prod.api.market/api/v1/magicapi/enhanced-background-removal-api

### Authentication
Include your API key in every request using the header:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API uses asynchronous processing for predictions:

1. Submit a prediction request (POST /api/v1/magicapi/enhanced-background-removal-api/predictions)  
2. Receive a prediction ID in the response  
3. Poll the GET /api/v1/magicapi/enhanced-background-removal-api/predictions/{id} endpoint periodically to get the status  
4. When the status is "succeeded," retrieve the output  
5. If the status is "failed," handle the error accordingly  

Suggested polling interval is 1 second, with a maximum timeout of 600 seconds (10 minutes).

### Endpoints

#### 1. Create a prediction
POST /api/v1/magicapi/enhanced-background-removal-api/predictions

Use this endpoint to submit an image for background removal.

• Request Body (JSON):
```json
{
  "input": {
    "image": "https://example.com/image.jpg"
  }
}
```
  
• Response Example (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "4067ee2a58f6c161d434a9c077cfa012820b8e076efa2772aa171e26557da919",
  "status": "starting",
  "created_at": "2025-05-18T08:21:01.266Z"
}
```

#### 2. Get prediction status
GET /api/v1/magicapi/enhanced-background-removal-api/predictions/{id}

Use this endpoint to check status or retrieve the final result of a previously submitted prediction.

• Response Example (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://example.com/output.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"
}
```

### cURL Examples

```bash
# Example for creating a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/enhanced-background-removal-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "image": "https://example.com/image.jpg"
    }
  }'

# Example for checking prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/enhanced-background-removal-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

## Status Codes
- 200 OK: Request succeeded  
- 201 Created: Prediction created successfully  
- 400 Bad Request: Invalid request or missing required data  
- 401 Unauthorized: Missing or invalid API key  
- 403 Forbidden: Valid key, but insufficient permissions  
- 404 Not Found: Resource (prediction, endpoint) not found  
- 429 Too Many Requests: Rate limit exceeded; implement backoff before retrying  
- 500 Internal Server Error: An error occurred on the server  
- 503 Service Unavailable: Temporary outage or maintenance  

## Rate Limits
Requests may be subject to rate limits based on your plan. If you receive a 429 (Too Many Requests), reduce the frequency of your requests and implement exponential backoff.

## Error Handling
When an error occurs, the API returns a JSON response containing details:

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

• Check the HTTP status code to determine the type of error.  
• Review the "message" field for guidance on what went wrong.  
• Correct the request or implement retry logic (with backoff) when errors are temporary.  

## Implementation Guide

Below are sample implementations in JavaScript, Python, and raw cURL. Adjust these examples to suit your environment. Ensure you handle asynchronous prediction status checks properly.

### JavaScript Example

```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/enhanced-background-removal-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 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"}`);
    }

    // Wait before polling again
    await delay(POLL_INTERVAL);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

// Usage example:
// createAndWaitForPrediction({ image: "https://example.com/image.jpg" })
//   .then(result => console.log("Output image URL:", result))
//   .catch(err => console.error("Error:", err));
```

### Python Example

```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/enhanced-background-removal-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", json={"input": input_data}, headers=headers)
    
    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")

# Usage example:
# result_url = create_and_wait_for_prediction({"image": "https://example.com/image.jpg"})
# print("Output image URL:", result_url)
```

### cURL Example

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

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

# 2. Poll for results using the prediction ID from step 1
curl -X GET "https://prod.api.market/api/v1/magicapi/enhanced-background-removal-api/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"

# Keep polling until status is "succeeded" or "failed".
```

### Performance Optimization
1. Batch requests where possible to limit overhead.  
2. Cache or store results to avoid duplicate requests.  
3. Implement proper rate-limiting and backoff strategies to manage spikes in usage.  

## FAQ
1. Q: How large can my images be?  
   A: The API can handle typical e-commerce product image resolutions. For very large files, consider resizing before uploading to speed up processing.  

2. Q: How quickly are images processed?  
   A: Processing time varies by image complexity, but typically completes within a few seconds. We recommend implementing the suggested asynchronous polling approach.  

3. Q: Can I use this API for bulk product catalogs?  
   A: Yes. The API is asynchronous and supports batching strategies, making it well suited for large-scale operations.  

4. Q: What if my image has multiple subjects?  
   A: The API attempts to remove the unified background. If you have multiple separate subjects, the API will still remove the background for the entire image but cannot currently isolate multiple foreground elements distinctly.  

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

Effortlessly remove image backgrounds with advanced matting for crisp, accurate cutouts. Ideal for e-commerce and design. Try it free on API.market.