Name: Datalab OCR – Detect & Transcribe Text | Pay Per Call | API.market
Brand: magicapi
SKU: api-magicapi-text-detection-transcription-api-datalab-to-ocr
Availability: InStock
Author: API Market

Shashank Agarwal

# 🔤 Accurate Text Detection & Transcription API (Datalab-to OCR)

## Overview
The Accurate Text Detection & Transcription API (Datalab-to OCR) enables you to detect, transcribe, and analyze text in images. This powerful OCR (Optical Character Recognition) model processes images and documents in 90 languages, providing accurate bounding boxes, layout analysis, reading order, and table recognition. The API supports various file types including PDFs, DOCs, PPTs, and images for seamless and versatile text extraction.

## Features
- **Multi-language Support**: Detects and transcribes text in 90 languages.
- **Precise Text Detection**: Identifies text regions with accurate bounding boxes.
- **Layout and Reading Order Analysis**: Analyzes the layout and reading order of text in documents.
- **Table Recognition**: Recognizes tables and extracts tabular data.
- **Visualization Support**: Generates annotated images with detected text regions.
- **Flexible Input Formats**: Supports .pdf, .doc, .docx, .ppt, .pptx, .png, .jpg, .jpeg, and .webp files.

## Use Cases
- **Document Digitization**: Convert paper documents into digital text for easy storage and retrieval.
- **Invoice Processing**: Automate the extraction of key data from invoices for accounting and financial purposes.
- **Archival and Indexing**: Process historical documents and images for archiving and indexing.
- **Text Extraction from Images**: Extract text from images for further analysis and manipulation.
- **Automated Data Entry**: Streamline data entry processes by automatically extracting text from various document types.

## Visual Examples
### Overview Example
![Sample Input Image](https://blog.api.market/wp-content/uploads/2026/02/text-detection-api-market.jpg)

### Example Annotations
![Annotated Output Image](https://blog.api.market/wp-content/uploads/2026/02/text-detection-output-api-market.jpg)

## Pricing
- **Pay As You Go (PAYG) Pricing**: You only pay for what you use.
- **1 API Unit**: Equals 1 image processed.
- **Free Status Checks**: GET requests to check prediction status are free and don't count toward API unit usage.
- **No Monthly Fees**: Simple per-call pricing without any monthly subscription fees or usage limits.

## API Documentation

### Base URL
All API requests should be made to: `https://prod.api.market/api/v1/magicapi/text-detection-transcription-api-datalab-to-ocr`

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

### Asynchronous Processing
**IMPORTANT**: This API uses asynchronous processing for predictions. The typical flow is:

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.

The processing time varies depending on the complexity of the request. Your code should implement:
- A polling interval of 1 second between status checks.
- A maximum timeout of 600 seconds (10 minutes).
- Status checking logic that continues while status is "starting" or "processing".
- Result handling when status becomes "succeeded".
- Error handling when status becomes "failed" or timeout is reached.

### Endpoints
#### Create Prediction
Create a new prediction.

**Endpoint**: `POST /api/v1/magicapi/text-detection-transcription-api-datalab-to-ocr/predictions`

**Request Example**:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-detection-transcription-api-datalab-to-ocr/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "3e6db0d5311d6fdc232eea333c1e26055ba4e542180043f12acb2967e5c77f4a",
    "input": {
      "file": "https://blog.api.market/wp-content/uploads/2026/02/text-detection-api-market.jpg",
      "visualize": true,
      "skip_cache": false,
      "return_pages": false
    }
  }'
```

**Response Example**:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "3e6db0d5311d6fdc232eea333c1e26055ba4e542180043f12acb2967e5c77f4a",
  "status": "starting",
  "created_at": "2026-02-03T07:24:50.738Z"
}
```

#### Get Prediction Status
Get the status and results of a prediction.

**Endpoint**: `GET /api/v1/magicapi/text-detection-transcription-api-datalab-to-ocr/predictions/{id}`

**Request Example**:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/text-detection-transcription-api-datalab-to-ocr/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Response Example**:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": {
    "text": "One Ring to rule them all\nOne Ring to find them\nOne Ring to bring them all\nand in the darkness bind them\nIn the Land of Mordor\nwhere the Shadows lie",
    "pages": null,
    "page_count": null,
    "visualizations": [
      "https://blog.api.market/wp-content/uploads/2026/02/text-detection-output-api-market.jpg"
    ]
  },
  "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**: Resource 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 not found.
- **429 Too Many Requests**: Rate limit exceeded.
- **500 Internal Server Error**: Server-side error.
- **503 Service Unavailable**: Service temporarily unavailable.

## Rate Limits
Information about any rate limits and how to handle them if applicable.

## Error Handling
- **Interpreting Error Responses**: Look for the `error` field in the JSON response.
- **Common Errors**:
  - Invalid parameter: Review the input data.
  - Unauthorized: Verify your API key.
  - Not Found: Confirm the resource ID.
- **Retry Strategies**:
  - Implement exponential backoff for retrying requests.
  - Adjust retry limits based on API rate limits and network stability.

**Error Response Example**:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'file' is required",
    "status": 400
  }
}
```

## Implementation Guide

### Example Code
#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/text-detection-transcription-api-datalab-to-ocr";

async function createAndWaitForPrediction(inputData) {
  try {
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({ version: "3e6db0d5311d6fdc232eea333c1e26055ba4e542180043f12acb2967e5c77f4a", input: inputData })
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }
    
    const prediction = await response.json();
    const predictionId = prediction.id;
    
    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;
  const POLL_INTERVAL = 1000;
  
  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();
    
    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
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/text-detection-transcription-api-datalab-to-ocr"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "3e6db0d5311d6fdc232eea333c1e26055ba4e542180043f12acb2967e5c77f4a", "input": input_data}
    )
    
    if response.status_code != 200:
        raise Exception(f"API error: {response.status_code} {response.text}")
    
    prediction = response.json()
    prediction_id = prediction["id"]
    
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600
    POLL_INTERVAL = 1
    
    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")

# Example usage:
input_data = {
    "file": "https://blog.api.market/wp-content/uploads/2026/02/text-detection-api-market.jpg",
    "visualize": True,
    "skip_cache": False,
    "return_pages": False
}

output = create_and_wait_for_prediction(input_data)
print(output)
```

#### cURL
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/text-detection-transcription-api-datalab-to-ocr/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "3e6db0d5311d6fdc232eea333c1e26055ba4e542180043f12acb2967e5c77f4a",
    "input": {
        "file": "https://blog.api.market/wp-content/uploads/2026/02/text-detection-api-market.jpg",
        "visualize": true,
        "skip_cache": false,
        "return_pages": false
    }
  }'

# Response will contain a prediction ID like:
# {"id": "wfawgjquxq", "status": "starting"}

# Step 2: Check prediction status (replace wfawgjquxq with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/text-detection-transcription-api-datalab-to-ocr/predictions/wfawgjquxq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Note: You need to repeatedly poll this endpoint manually until status is "succeeded"
```

### Performance Optimization
- **Batch Processing**: Where possible, batch multiple requests into a single file to optimize processing time and cost.
- **Cache Results**: Use the `skip_cache` parameter judiciously to avoid unnecessary reprocessing and reduce costs.

## FAQ
- **Q: What formats are supported for text extraction?**
  - A: The API supports .pdf, .doc, .docx, .ppt, .pptx, .png, .jpg, .jpeg, and .webp files.
  
- **Q: How long does it take to process a document?**
  - A: Processing time depends on the complexity of the document but typically completes within a few seconds to a few minutes.
  
- **Q: Is there a limit on the number of pages that can be processed?**
  - A: The `max_pages` parameter allows you to set a limit. If `page_range` is specified, processing will cover the specified range of pages.

- **Q: Can I get detailed information for each page processed?**
  - A: Yes, by setting the `return_pages` parameter to `true`, you can get detailed page information including text lines, bounding boxes, polygons, and character-level data.

## 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, transcribe, and analyze text from images and documents in over 90 languages. Try it free on API.market.