Name: YOLOE-L – Real-Time Object Detection | $0.01/call | API.market
Brand: magicapi
SKU: api-magicapi-real-time-object-detection-api
Availability: InStock
Rating: 5.00 (1 reviews)
Author: API Market

Shashank Agarwal

# 🔎 Ultra-Fast Object Detection API (YOLOE-L by Ultralytics)

## Overview
The Ultra-Fast Object Detection API (powered by the YOLOE-L model) enables real-time object detection and classification in images. With 26.2M parameters, this model achieves an impressive 52.6 mAP50-95 on the COCO dataset in a compact and efficient design. Ideal for scenarios where speed and accuracy are critical, this API can detect multiple object categories simultaneously and return bounding box coordinates along with class labels.

## Features
- State-of-the-art YOLOE-L Model (26.2M parameters)  
- High-speed inference optimized for real-time applications  
- Impressive 52.6 mAP50-95 precision on COCO  
- Configurable confidence (conf) and IoU (iou) thresholds  
- Flexible output format (image with bounding boxes, or JSON)  
- Pay-as-you-go pricing with no monthly fees  

## Use Cases
1. Retail Security and Loss Prevention  
   - Automatically detect unauthorized activities in-store surveillance footage.  
   - Rapid real-time insights for improved loss prevention strategies.  

2. Autonomous Vehicles and Traffic Monitoring  
   - Enhance detection of pedestrians, traffic signs, and vehicles.  
   - Real-time alerts to improve safety and reduce accidents.  

3. Wildlife Monitoring and Conservation  
   - Track endangered species in remote camera feeds.  
   - Instant detection of poachers or unauthorized activities in protected zones.  

4. Smart Home and Office Automation  
   - Real-time detection of people or objects for energy-saving measures (e.g., lights on/off).  
   - Security monitoring to intelligently identify potential intruders.  

5. E-commerce Product Tagging  
   - Automatically identify and tag products in lifestyle images or user-submitted images.  
   - Streamlined product cataloging with high accuracy and minimal oversight.  

## Visual Examples

### Example of an Input Image:
Below is an example input image showing a person (and possibly additional objects).

![Input image featuring a person](https://replicate.delivery/pbxt/NTtjUiuyEUPRWwjCjGmdwAuP2lLSm720z4jUFF5uZbChzeTU/zidane.jpg)

### Example of an Output Image:
Here is an example output image with bounding boxes visually identifying objects.

![Output image showing detected objects](https://replicate.delivery/xezq/ODXsLo0RWh7hEdNmxivbO6UlCaFaB1eV3JfvDyidos1loePqA/output.png)

These examples illustrate how the API overlays bounding boxes around detected objects when you choose to receive results as an annotated image.

## Pricing
- Pay As You Go (PAYG): You only pay for what you use.  
- 1 API unit equals 1 image processed.  
- GET requests to check prediction status (GET /api/v1/magicapi/real-time-object-detection-api/predictions/{id}) are free and do not count toward API unit usage.  
- 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/real-time-object-detection-api
```

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

### Asynchronous Processing
This API uses asynchronous prediction processing. The typical flow is:

1. Submit a POST request to create a prediction (includes your input images and model parameters).  
2. You receive a prediction ID in the response.  
3. Poll the GET /predictions/{id} endpoint periodically to check status.  
4. Once status is "succeeded," retrieve the processed results.  

We recommend:  
- A 1-second polling interval.  
- A maximum timeout of 600 seconds (10 minutes).  

### Endpoints

#### 1. Create a Prediction
Creates a new prediction job.

• Method: POST  
• Endpoint:  
  ```
  /api/v1/magicapi/real-time-object-detection-api/predictions
  ```  
• Request Body (JSON):
```json
{
  "input": {
    "image": "https://example.com/image.jpg",
    "conf": 0.25,
    "iou": 0.45,
    "imgsz": 640,
    "class_names": "person, tie",
    "return_json": false
  }
}
```
- image (required): The URL of the image.  
- conf (optional): Confidence threshold (0–1, default 0.25).  
- iou (optional): IoU threshold for NMS (0–1, default 0.45).  
- imgsz (optional): Image size (default 640).  
- class_names (optional): Comma-separated list of class names to filter.  
- return_json (optional): If true, returns raw JSON data of object detection.  

• Example cURL:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/real-time-object-detection-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "image": "https://example.com/image.jpg",
      "conf": 0.25,
      "iou": 0.45,
      "imgsz": 640,
      "class_names": "person, tie",
      "return_json": false
    }
  }'
```

• Example Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "34f9a9913b17b0afcd75116cdcf8c3463e3763cfeda7751c041cfbe6c9b4958e",
  "status": "starting",
  "created_at": "2025-08-17T17:38:35.797Z"
}
```

#### 2. Get Prediction Status and Results
Fetches the prediction status and, if completed, the result.

• Method: GET  
• Endpoint:  
  ```
  /api/v1/magicapi/real-time-object-detection-api/predictions/{id}
  ```  
• Path Parameter:
  - id (required): The prediction ID you received from the POST response.

• Example cURL:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/real-time-object-detection-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

• Example Response (200 OK, when succeeded):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": {
    "image": "https://example.com/path-to-output-image.png",
    "json_str": "{\"detections\": ...}"
  },
  "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: The resource (prediction) was 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 (prediction) not found.  
- 429 Too Many Requests: Rate limit exceeded.  
- 500 Internal Server Error: Could not process the request due to a server-side issue.  
- 503 Service Unavailable: Service is temporarily unavailable; retry later.  

## Rate Limits
The API applies rate limiting to ensure optimal service availability. If you exceed rate limits, you may receive a 429 Too Many Requests response. In that case, implement a backoff strategy (e.g., exponential backoff) before retrying.

## Error Handling
To handle errors:
1. Check the HTTP status code.  
2. If it indicates a client error (4xx), inspect the message to correct the request.  
3. For server errors (5xx), retry the request after a short delay.  

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

## Implementation Guide

### Example Code

Below are sample implementations in JavaScript, Python, and cURL to help you integrate asynchronous object detection.

#### JavaScript (Node.js)
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/real-time-object-detection-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) {
    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 if completed
    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
```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/real-time-object-detection-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    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:
        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")
```

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

# Step 2: Poll for prediction status (using the returned ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/real-time-object-detection-api/predictions/abcd1234" \
     -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
1. Batch your requests if possible to reduce overhead.  
2. Use smaller image sizes (e.g., imgsz=320) when high resolution is not needed.  
3. Filter detection classes (class_names) if your use case only requires specific objects, reducing processing time and noise in the results.  

## FAQ
1. How long does a typical prediction take?  
   - Most predictions complete within a few seconds, but this can vary based on image size and complexity.

2. Can I filter only specific object classes?  
   - Yes, use the class_names parameter (e.g., "person, bus"). Leave it empty to detect all classes.

3. Is there a limit to the number of images I can process?  
   - There is no strict limit. However, if you exceed certain rate limits, you may receive a 429 response. Simply implement a retry or contact support for higher throughput.

4. Do I pay for status checks?  
   - No, GET requests to check status are free.

5. What image formats does the API support?  
   - The API works best with JPG/PNG images accessible via a public URL.

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

Detect and classify objects in images with the YOLOE-L model. 52.6 mAP accuracy. From $0.01/call. Try it free on API.market.

YOLOE-L – Real-Time Object Detection | $0.01/call | API.market

🔎 Ultra-Fast Object Detection API (YOLOE-L by Ultralytics)

PAYG

MagicAPI

the ultra-fast object detection api (yoloe-l) is quick and accurate—spots multiple objects in real time with solid precision. perfect for security, traffic, or any project needing fast reliable detection.