Name: Bria Eraser – Object Removal | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-ai-object-removal-image-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 🗑️ High-Quality Object Removal API (bria/eraser)

## Overview
The High-Quality Object Removal API (bria/eraser) lets you remove unwanted objects from images with industry-leading precision. It supports both manual and automatic masking, enabling fine-grained control over which parts of the image to remove. The entire model was trained exclusively on licensed data, making it safe for commercial use. Whether you are building photo editing tools, e-commerce product image enhancements, or creative applications, this API ensures high-quality output every time.

![Example of removing an unwanted item using a manual mask](https://blog.api.market/wp-content/uploads/2026/01/background-remover-api-market.png)

## Features
- Removes objects with state-of-the-art precision  
- Maintains image quality after object removal  
- Accepts both local images and URLs for convenience  
- Supports both manual and automatic masking modes  
- Commercially safe model, trained on properly licensed data  
- High-speed performance suitable for real-time user-facing applications  

## Use Cases
1. **E-Commerce Background Cleaning**  
   Remove distracting objects or background details from product images to maintain a consistent, sleek visual presentation for storefronts.

2. **Creative Photo Editing**  
   Enhance user-generated content by enabling them to remove undesired elements in selfies, group shots, or scenic photos, perfect for social media and photography apps.

3. **Advertising and Marketing**  
   Quickly clean up or repurpose existing visual assets for ad campaigns—removing text overlays, branding, or objects no longer relevant.

4. **Real Estate Photography**  
   Eliminate clutter or personal items from property images, delivering clean, inviting property photos that highlight the space.

5. **Digital Media and Publishing**  
   Swiftly edit editorial photos or promotional images to comply with layout requirements, removing extraneous elements so the focus remains on the primary subject.  

## Visual Examples
Below are more detailed visual demonstrations of how the API transforms an image.  

### Example Mask and Output
• Input image URL (for demonstration):  
![Original image to remove objects from](https://blog.api.market/wp-content/uploads/2026/01/bg-remover-api-market.jpg)

• Associated manual mask URL (indicates the region to remove):  
![Mask image indicating the removal region](https://blog.api.market/wp-content/uploads/2026/01/background-remover-api-market.png)

• Output (with object removed):  
![Resulting image after removing the masked object](https://blog.api.market/wp-content/uploads/2026/01/bg-remover-output-api-market.png)

These examples demonstrate how precisely the unwanted item can be removed while preserving the overall image quality and content.

## Pricing
• Pay As You Go (PAYG) - Pay only for the images you process.  
• 1 API unit = 1 image processed.  
• GET requests to check prediction status (GET /api/v1/magicapi/ai-object-removal-image-api/predictions/{id}) are free and do not count toward usage.  
• No monthly subscription fees or usage limits – simple per-call pricing.  

## API Documentation

### Base URL
All API requests should be sent to:  
```
https://prod.api.market/api/v1/magicapi/ai-object-removal-image-api
```

### Authentication
Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```
Replace "YOUR_API_MARKET_KEY" with your actual API key from API.market account.

### Asynchronous Processing
This API uses asynchronous processing for predictions (object removal jobs). The flow is as follows:
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.  

Processing time depends on the complexity of your image and request. Use a 1-second interval between checks, with a maximum timeout of 10 minutes. Stop polling when:
- The status is "succeeded" — your output is ready.  
- The status is "failed" — the request did not succeed.  
- 600 seconds have elapsed (timeout).  

### Endpoints

#### 1) Create a Prediction
POST /api/v1/magicapi/ai-object-removal-image-api/predictions

• Description: Submits a request to remove objects from an image  
• Required body fields:  
  - "input" (object containing image, mask, or relevant fields)  
• Response returns the prediction ID and initial status.

Example request:

```bash
# Example for creating a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-object-removal-image-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "image": "https://example.com/image.jpg",
      "mask_url": "https://example.com/mask.png",
      "mask_type": "manual",
      "preserve_alpha": true
    }
  }'
```

Example response:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "d0363b3041536a2abdca74ce946bf5dead597ae92bd01f2b4ecaaaec5ef8c5de",
  "status": "starting",
  "created_at": "2025-07-11T07:19:33.948Z"
}
```

#### 2) Get Prediction Status and Results
GET /api/v1/magicapi/ai-object-removal-image-api/predictions/{id}

• Description: Retrieves the current status of a prediction request. Once the status is "succeeded," the "output" field contains the link to the edited image.  
• Path Parameter:
  - {id}: The unique prediction ID returned when you created the prediction.

Example request:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-object-removal-image-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

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

## Status Codes
- 200 OK: Request was successful.  
- 201 Created: When a new resource/prediction is created successfully (e.g., POST to /predictions).  
- 400 Bad Request: Invalid or missing input parameters. Check your JSON structure and required fields.  
- 401 Unauthorized: Missing or invalid API key. Make sure to provide the correct header.  
- 403 Forbidden: Your API key is valid, but you do not have permission for this specific action.  
- 404 Not Found: The specified resource or prediction ID does not exist.  
- 429 Too Many Requests: You have exceeded your rate limit. Implement exponential backoff or wait to retry.  
- 500 Internal Server Error: An error occurred on the server side. Try again later or contact support.  
- 503 Service Unavailable: The service may be temporarily down or overloaded. Try again after some time.  

## Rate Limits
Requests may be subject to rate limiting:
- If you exceed your rate limit, the API returns HTTP 429 (Too Many Requests).  
- Implement retries with backoff if you receive a 429 response.  

## Error Handling
Error responses will generally include a JSON object describing the problem:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```
- Always check the "message" and "code" fields to understand the cause.  
- If you encounter persistent errors, verify that your request matches the required schema and contact support if needed.  

## Implementation Guide

Below are example implementations in JavaScript, Python, and Bash demonstrating how to properly authenticate, send prediction requests, poll for status, and handle timeouts.

### JavaScript Example

```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ai-object-removal-image-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-api-market-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 between checks
  
  const startTime = Date.now();
  
  while (Date.now() - startTime < MAX_TIMEOUT) {
    // Check prediction status
    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();
    
    // Check status and return if completed
    if (prediction.status === "succeeded") {
      return prediction.output;
    }
    
    // Handle failure
    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

```python
# Python example with proper polling and timeout
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/ai-object-removal-image-api"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    
    # Step 1: Create the prediction
    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 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 between checks
    
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()
    
    while time.time() - start_time < MAX_TIMEOUT:
        # Check prediction status
        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()
        
        # Check status and return if completed
        if prediction["status"] == "succeeded":
            return prediction["output"]
        
        # Handle failure
        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/ai-object-removal-image-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "image": "https://example.com/image.jpg",
      "mask_type": "manual",
      "preserve_alpha": true
    }
  }'

# Example response:
# {"id":"abcd1234","status":"starting","version":"d0363b3041536..."}

# Step 2: Check the prediction status (replace abcd1234 with the returned ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-object-removal-image-api/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Poll this endpoint until "status" is "succeeded" or "failed".
```

### Performance Optimization
- Reduce the size of your images before uploading for faster processing.  
- Use efficient polling intervals (1 second) and handle timeouts gracefully.  
- Only submit new requests when you truly need them to optimize costs.  

## FAQ
1. **How large can the images be?**  
   You can generally submit images up to a few megabytes. Larger images may take longer to process.  

2. **Does the API preserve the alpha channel of PNG images?**  
   Yes, by default the API will preserve alpha if you set "preserve_alpha" to true.  

3. **Do I need to provide a mask?**  
   You can provide a manual mask or specify "automatic" to let the system detect and remove objects.  

4. **What if my prediction fails?**  
   Check the "error" field in the response for more details. Common causes include invalid image URLs or improper input structure.  

5. **Are status checks free?**  
   Yes, any GET requests to check prediction status are free and do not count toward your usage.  

## 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 unwanted objects, people, or text from any image. Trained on licensed data for commercial use. From $0.05/call. Try it free on API.market.

Bria Eraser – Object Removal | $0.05/call | API.market

🗑️ High-Quality Object Removal API (bria/eraser)

PAYG

MagicAPI

Effortlessly remove unwanted objects from images with SOTA precision and maintain stunning image quality—commercially safe and lightning-fast for developers.