Name: Simple Image Text Extraction API - AI-Powered Text Recognition
Brand: magicapi
SKU: api-magicapi-simple-image-text-extraction-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 📝 Fast Image Text Extraction API (abiruyt/text-extract-ocr)

## Overview
The Fast Image Text Extraction API (abiruyt/text-extract-ocr) provides a quick and efficient way to convert images into searchable, editable text. Powered by a lightweight OCR engine, this API is perfect for data entry, document indexing, and automation of text extraction workflows.

![Sample input for text extraction](https://replicate.delivery/pbxt/KhTOXyqrFtkoj2hobh1a4As6dYDIvNV2Ujbc0LbGD9ZguRwR/bowers.jpg)

By simply providing a publicly accessible image URL, the API processes the image asynchronously and returns extracted text with high accuracy.

## Features
- Fast and reliable OCR for various image formats
- Lightweight engine with minimal latency
- High accuracy, even with moderate image quality
- Asynchronous processing for efficient, scalable workflows
- Straightforward integration via simple REST endpoints

## Use Cases
1. Document Management for Enterprises and SMBs:
   - Automate indexing of scanned documents for easy storage and retrieval.  
   - Integrate into existing document workflows to quickly extract text from paper-based records.

2. Legal & Financial Services:
   - Rapidly convert scanned contracts, invoices, or receipts into editable text.  
   - Improve due diligence processes by automating extraction of key data fields.

3. E-commerce Catalog Management:
   - Automate the extraction of product descriptions from packaging images.  
   - Speed up the process of adding items to online stores.

4. Healthcare Record Digitization:
   - Extract text from patient records or lab reports rapidly.  
   - Reduce manual data entry errors in sensitive clinical workflows.

5. Education & Research:
   - Quickly analyze archival documents, manuscripts, or historical texts.  
   - Convert scanned pages to digital text for text mining or linguistic analysis.

## Visual Examples

### Example Input
Below is an example of an input image for OCR:

![Input image containing sample text](https://replicate.delivery/pbxt/KhTOXyqrFtkoj2hobh1a4As6dYDIvNV2Ujbc0LbGD9ZguRwR/bowers.jpg)

### Example Output
Here is a snippet of the output text extracted from the above image:

```
The Life and Work of
Fredson Bowers

by
G. THOMAS TANSELLE

N EVERY FIELD OF ENDEAVOR THERE ARE A FEW FIGURES WHOSE AGCOM-
plishment and influence cause them to be the symbols of their age;
their careers and oeuvres become the touchstones by which the
field is measured...
```

This shows how the API takes in a JPEG image containing text and returns plain text.

## Pricing
- 1 API unit equals 1 image processed.  
- GET requests (checking prediction status) are free and do not consume any API units.  
- Different pricing tiers are available based on usage volume (please check your account dashboard on API.market for specific plans).

## API Documentation

### Base URL
All API requests described below should be made to:
```
https://prod.api.market/api/v1/magicapi/simple-image-text-extraction-api
```

### Authentication
Use your API key from API.market in the request header:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```
Your requests will be authorized based on this key.

### Asynchronous Processing
This API uses asynchronous processing. The typical workflow is:
1. Send a POST request to create a new prediction.  
2. Receive a prediction ID in the response.  
3. Poll the GET endpoint with the prediction ID to check its status.  
4. Continue polling until the prediction is complete (status becomes "succeeded") or fails.

Processing time depends on image size and complexity. Implement:
- A polling interval of 1 second.  
- A maximum timeout of 600 seconds (10 minutes).  
- Logic to handle "starting" or "processing" statuses, and a final "succeeded" or "failed" result.

### Endpoints

#### 1. Create a Prediction
• Endpoint:  
  POST /api/v1/magicapi/simple-image-text-extraction-api/predictions

• Description:  
  Submits an image for text extraction.

• Request Body Parameters (JSON):
```
{
  "input": {
    "image": "https://example.com/image.jpg"
  }
}
```
(image must be a publicly accessible URL)

• Example Request:

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/simple-image-text-extraction-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 (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "a524caeaa23495bc9edc805ab08ab5fe943afd3febed884a4f3747aa32e9cd61",
  "status": "starting",
  "created_at": "2023-01-01T12:00:00.000Z"
}
```
Where:
- id: Unique identifier for the prediction  
- status: Current status, one of [starting, processing, succeeded, failed, canceled]  

#### 2. Get Prediction Status and Results
• Endpoint:  
  GET /api/v1/magicapi/simple-image-text-extraction-api/predictions/{id}

• Description:  
  Retrieves the status and any available output for a given prediction.

• Path Parameter:
  - id (required): The unique identifier returned when you created the prediction.

• Example Request:

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/simple-image-text-extraction-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

• Example Response (200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "The Life and Work of\nFredson Bowers\n\n...",
  "error": null,
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```
Where:
- output: The extracted text when status is "succeeded"  
- error: Error message if status is "failed"  

### Status Codes
- 200 OK: The request was successful.  
- 201 Created: The resource was successfully created (e.g., a new prediction).  
- 400 Bad Request: Your request is invalid or the parameters are incorrect.  
- 401 Unauthorized: Missing or invalid API key.  
- 403 Forbidden: Valid API key but insufficient permissions.  
- 404 Not Found: The specified resource (e.g., prediction ID) cannot be found.  
- 429 Too Many Requests: You have exceeded your rate limits.  
- 500 Internal Server Error: A server-side error occurred.  
- 503 Service Unavailable: Service is temporarily unavailable or under maintenance.

### Rate Limits
Requests are rate-limited to ensure stability. If you hit the 429 Too Many Requests status, reduce your request frequency or upgrade your plan.

## Error Handling
When an error occurs, the API returns a JSON response with details. Common causes:
- Missing or malformed parameters.
- Invalid API key or insufficient funds.
- Rate limit exceeded.

Example error response:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```
**Suggested strategies:**  
- Check the error message to identify the root cause.  
- Correct your parameters or handle the error in your application.  
- Implement retries with backoff if errors are transient.

## Implementation Guide

Below are sample implementations demonstrating how to:
1. Send a prediction request (POST).  
2. Poll for results (GET).  
3. Implement timeout and error handling for long-running operations.

### 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/simple-image-text-extraction-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 between checks
  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    // Check prediction status
    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();

    // 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 a moment before the 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/simple-image-text-extraction-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",
        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
    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()
        
        # Check status
        if prediction["status"] == "succeeded":
            return prediction["output"]
        elif prediction["status"] == "failed":
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")
        
        # Wait before next poll
        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/simple-image-text-extraction-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 contain a prediction ID, e.g.:
# {"id": "abcd1234", "status": "starting"}

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

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

## Performance Optimization
- Resize or compress large images before sending to reduce processing time and costs.  
- Implement polling intervals of 1-2 seconds to reduce unnecessary API calls.  
- Monitor your usage and switch to higher-tier plans if you need more throughput.

## FAQ
1. What image formats are supported?  
   Typically, JPEG, PNG, and GIF. However, any publicly accessible image URL should work.

2. How can I improve OCR accuracy?  
   Provide clear, high-resolution images with minimal compression artifacts.

3. Are GET requests for checking status charged?  
   No. Status checks for a prediction are free.

4. Is there a maximum image size?  
   The system can handle moderately large images, but for the best performance keep images under a few MB in size.

5. What if my prediction times out?  
   Increase your timeout or ensure the image is accessible and not too large. You may also retry if needed.

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

Buy the Simple Image Text Extraction API to extract text from images effortlessly. Enhance your OCR capabilities with AI-powered solutions. Buy from API Market!