Name: rembg – Remove Image Backgrounds | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-instant-image-background-removal-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 🪄 Ultra-Fast Image Background Remover API (rembg)

## Overview
The Ultra-Fast Image Background Remover API swiftly removes backgrounds from your images with impressive accuracy. Whether you’re managing product images for an e-commerce platform or crafting social media content, this API quickly processes your images and returns a polished result ready for your next step.

## Features
- High-accuracy background removal  
- Optimized for speed and large volume processing  
- Simple asynchronous usage pattern  
- Works with any image URL  
- Returns a transparent PNG (or similar format) with the background removed  

## Use Cases
1. E-commerce Product Photography  
   • Effortlessly strip away backgrounds for product listings  
   • Ensure consistent, professional-looking catalogs  

2. Social Media Content Creation  
   • Remove busy backgrounds from personal or branded images  
   • Quickly create memes, profile pictures, or custom stickers  

3. Marketing Collaterals  
   • Simplify design tasks by focusing on the subject of the image  
   • Create promotional materials with uniform backgrounds  

4. Photography & Photo Editing Services  
   • Automate tedious background removal tasks for faster workflows  
   • Easily integrate into existing photo production pipelines  

5. Web & App Development  
   • Provide an instant user experience for photo editing within apps  
   • Allow end-users to create transparent images without advanced tools  

## Visual Examples

### Sample Input Image
![Sample input image of an animal](https://blog.api.market/wp-content/uploads/2025/12/animal-api-market.jpeg)

### Sample Output Image
![Sample output image with the background removed](https://blog.api.market/wp-content/uploads/2025/12/animal-output-api-market.png)

These examples demonstrate how the input image is transformed by removing the background, leaving only the subject.

## Pricing
• 1 API unit = 1 image processed.  
• GET requests to check prediction status (GET /api/v1/magicapi/instant-image-background-removal-api/predictions/{id}) are free and do not count toward API unit usage.  
• Tiered pricing is available, allowing more cost-effective rates with higher-volume usage.  

## API Documentation

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

### Authentication
To authenticate, include your API key in the header:  
```
x-magicapi-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API processes image background removal asynchronously. Follow this flow:  
1. Submit a POST request to create a prediction (background removal job).  
2. Receive a prediction ID.  
3. Poll the GET endpoint with the prediction ID to check the job status.  
4. Continue polling until the job status changes to "succeeded" or "failed."  

Typical wait time depends on factors such as image size, but a 1-second polling interval with a maximum 600-second timeout is recommended.

### Endpoints

#### 1. Create a Prediction
• Endpoint:  
  POST /api/v1/magicapi/instant-image-background-removal-api/predictions  

• Description:  
  Initiates a new background removal prediction.

• Example Request:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/instant-image-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"
    }
  }'
```

• Expected Response (201 Created on success)  
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "fb8af171cfa1616ddcf1242c093f9c46bcada5ad4cf6f2fbe8b81b330ec5c003",
  "status": "starting",
  "created_at": "2025-05-18T08:20:56.976Z"
}
```
Fields:  
- id: Unique identifier for the prediction.  
- version: Model version used.  
- status: Current status (starting, processing, succeeded, failed, canceled).  

#### 2. Get Prediction Status
• Endpoint:  
  GET /api/v1/magicapi/instant-image-background-removal-api/predictions/{id}  

• Description:  
  Retrieves the status and (once complete) the result of a background removal prediction.

• Example Request:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/instant-image-background-removal-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

• Expected Response (200 OK on success)
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2025/12/animal-output-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"
}
```
Fields:  
- status: Could be starting, processing, succeeded, failed, or canceled.  
- output: Contains the direct URL of the processed image if status is “succeeded.”  

## Status Codes
- 200 OK: Request was successful.  
- 201 Created: Prediction creation succeeded.  
- 400 Bad Request: Invalid parameters or malformed request.  
- 401 Unauthorized: Missing or invalid API key.  
- 403 Forbidden: Valid API key but insufficient permissions.  
- 404 Not Found: Requested resource or prediction ID not found.  
- 429 Too Many Requests: Rate limit exceeded.  
- 500 Internal Server Error: An error occurred on the server side.  
- 503 Service Unavailable: Service is temporarily overloaded or under maintenance.

## Rate Limits
Depending on your subscription tier, you may have a fixed number of images you can process per second or per minute. If you receive a 429 error, reduce your request rate or upgrade your plan.

## Error Handling
When the API returns an error, it includes a descriptive message in JSON format. For example:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```

### Common Errors
• invalid_parameter: Typically indicates missing or malformed fields in the request body.  
• unauthorized: Check that your API key is correct.  
• rate_limit_exceeded: Throttle requests or increase your usage tier.  

### Retries & Best Practices
- Wait a short period (e.g., 1 second) before retrying a request that failed due to transient errors.  
- For rate-limited scenarios, follow the retry-after header if present or wait a few seconds before reattempting.

## Implementation Guide
Below are examples demonstrating how to integrate this asynchronous API into your project.  

### JavaScript Example (Node.js with fetch)
```javascript
// Replace with your actual API key
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/instant-image-background-removal-api";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const createResponse = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-magicapi-key": apiKey
      },
      body: JSON.stringify({ input: inputData })
    });

    if (!createResponse.ok) {
      throw new Error(`API error: ${createResponse.status} ${createResponse.statusText}`);
    }

    const prediction = await createResponse.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 statusResponse = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-magicapi-key": apiKey
      }
    });

    if (!statusResponse.ok) {
      throw new Error(`API error: ${statusResponse.status} ${statusResponse.statusText}`);
    }

    const prediction = await statusResponse.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");
}

// Example usage
// (async () => {
//   const result = await createAndWaitForPrediction({
//     image: "https://example.com/image.jpg"
//   });
//   console.log("Background removed image URL:", result);
// })();
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/instant-image-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
    }
    create_response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"input": input_data}
    )
    
    if create_response.status_code != 200 and create_response.status_code != 201:
        raise Exception(f"API error: {create_response.status_code} {create_response.text}")
    
    prediction = create_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
    start_time = time.time()

    while time.time() - start_time < MAX_TIMEOUT:
        response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers={"x-magicapi-key": API_KEY}
        )
        
        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")

# Example usage
# if __name__ == "__main__":
#     result_url = create_and_wait_for_prediction({
#         "image": "https://example.com/image.jpg"
#     })
#     print("Result:", result_url)
```

### cURL Example
```bash
# 1. Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/instant-image-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 response might look like:
# {
#   "id": "abcd1234",
#   "status": "starting"
# }

# 2. Poll the prediction status until it succeeds or fails
curl -X GET "https://prod.api.market/api/v1/magicapi/instant-image-background-removal-api/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"

# Keep checking this endpoint until "status": "succeeded" or "failed"
```

### Performance Optimization
- Minimize the number of concurrent requests if you’re on a lower tier plan to avoid throttling.  
- Use a 1-second polling interval as recommended, but tune if needed based on your usage pattern.  
- Cache or store results to avoid repeated calls for the same image.  

## FAQ

1. How fast is the background removal?  
   Typically, it takes a few seconds. Speed may vary depending on image complexity.  

2. Do I need to maintain a server for the asynchronous polling?  
   You can run the polling logic from any environment capable of making HTTP requests and waiting for a response (client-side, server-side, or serverless functions).  

3. Is there a maximum image size?  
   Images larger than a few MB will still process, but we recommend optimizing (resizing) images when possible.  

4. Which image formats are supported?  
   Common formats such as JPG, PNG, and GIF should work.  

5. What happens if I reach my usage limit?  
   You will receive a 429 Too Many Requests response. Contact us to discuss upgrading your plan.

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

Remove image backgrounds with impressive accuracy and speed. Returns a transparent PNG from any image URL. From $0.05/call. Try it free on API.market.