Name: EasyOCR API: Extract Text from Images
Brand: magicapi
SKU: api-magicapi-text-extraction-from-images-zsxkib-easyocr
Availability: InStock
Author: API Market

Shashank Agarwal

# 📸 OCR Text Extraction API (JaidedAI EasyOCR)

## Overview
EasyOCR extracts text from screenshots and images, with the position of every text region. Send an `image` and get back a Markdown file with the extracted text plus a JSON metadata string listing each region's text, confidence and coordinates.

Its developer describes it as multi-language and suited to camera-translation overlays. Optional preprocessing (contrast, sharpening, deskewing, binarization, shadow removal) helps with scans and photos of pages.

## Features
- **Languages**: `auto` (default), `en`, `es`, `fr`, `de`, `it`, `pt`, common combinations, or `custom` with your own codes in `custom_languages`.
- **Coordinates**: `include_bboxes` (default `true`) adds `x1`, `y1`, `x2`, `y2` per region; `include_polygons` adds a 4-point polygon.
- **Confidence filter**: `min_confidence` from 0 to 1 (default 0.4).
- **Preprocessing**: `preprocessing`, `clahe`, `sharpen`, `deskew`, `trim_borders`, `binarize`, `morph_op`, `denoise_strength`, `remove_shadow_strength` and `upscale_min_dim`.
- **Text cleanup**: `dehyphenate`, `normalize_quotes`, `remove_page_numbers`, `block_rare_symbols`, `allow_basic_punct` and `allow_brackets`.
- **Decoder and merging**: `ocr_decoder` (`beamsearch` or `greedy`), `beam_width`, `merge_level` and `autotune`.

## Use Cases
1. **Screenshot text**: read text and its position from app or web screenshots.
2. **Translation overlays**: get region coordinates to place translated text over the original.
3. **Scanned pages**: extract text from photos and scans of printed pages.
4. **Search and indexing**: turn image text into searchable Markdown.

## Visual Examples
### Example Input
![EasyOCR example input: a photographed printed book page](https://blog.api.market/wp-content/uploads/2026/10/easyocr-input-api-market.webp)

`languages`: `en`, `preprocessing`: `true`, `include_bboxes`: `true`, `include_polygons`: `false`, `text_only`: `false`, `min_confidence`: `0.25`.

### Example Output
The model found 14 text regions with an average confidence of 0.837. The `regions` list below is shortened to the first and last region:

```json
{
  "total_regions": 14,
  "avg_confidence": 0.837,
  "languages_used": [
    "en"
  ],
  "preprocessing_applied": true,
  "include_bboxes": true,
  "include_polygons": false,
  "text_only": false,
  "regions": [
    {
      "text": "THE VELVETEEN",
      "confidence": 0.7319959206050128,
      "x1": 99,
      "y1": 0,
      "x2": 657,
      "y2": 41
    },
    {
      "text": "48 _",
      "confidence": 0.5110713290703586,
      "x1": 339,
      "y1": 1069,
      "x2": 411,
      "y2": 1117
    }
  ]
}
```

`markdown` is the URL of a Markdown file with the extracted text. Its content, shortened here to the heading, the start of the first paragraph and the last line:

```markdown
# THE VELVETEEN RABBIT

He said, You become. It takes along ...

# 48 _
```

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `image` | string (URL) | Yes | none |  | Screenshot or image URL |
| `languages` | string | No | `auto` | `auto`, `en`, `es`, `fr`, `de`, `it`, `pt`, `en,es`, `en,es,fr`, `en,es,fr,de`, `en,es,fr,de,it,pt`, `custom` | Languages preset or custom list |
| `custom_languages` | string | No | `""` |  | Custom language codes (comma-separated), used when languages is custom |
| `ocr_decoder` | string | No | `beamsearch` | `greedy`, `beamsearch` | Text decoder |
| `beam_width` | integer | No | `7` | `1` to `15` | Beam width (when decoder=beamsearch) |
| `allow_basic_punct` | boolean | No | `true` |  | Restrict to common punctuation to avoid odd symbols |
| `allow_brackets` | boolean | No | `false` |  | Permit brackets []{}<> |
| `merge_level` | string | No | `auto` | `auto`, `low`, `medium`, `high` | Text merging strength |
| `autotune` | boolean | No | `true` |  | Try a few parameter combos and pick best |
| `block_rare_symbols` | boolean | No | `true` |  | Block uncommon symbols ($§•◊ etc.) |
| `preprocessing` | boolean | No | `true` |  | Apply preprocessing (recommended) |
| `upscale_min_dim` | integer | No | `900` | `0` to `4000` | Upscale small images so the shorter side reaches this size (px) |
| `clahe` | boolean | No | `true` |  | Apply mild CLAHE contrast enhancement |
| `denoise_strength` | integer | No | `0` | `0` to `15` | Denoising strength (0=off, 1-15) |
| `sharpen` | boolean | No | `true` |  | Apply mild unsharp mask to preserve small punctuation |
| `deskew` | boolean | No | `true` |  | Deskew small angles |
| `trim_borders` | boolean | No | `true` |  | Trim outer borders |
| `invert_strategy` | string | No | `auto` | `auto`, `force`, `disable` | Ensure dark text on light background |
| `binarize` | string | No | `none` | `none`, `otsu`, `adaptive_mean`, `adaptive_gaussian` | Binarization mode (for scans) |
| `morph_op` | string | No | `none` | `none`, `dilate`, `erode`, `open`, `close` | Morphology op after binarize |
| `morph_kernel` | integer | No | `0` | `0` to `15` | Morph kernel size |
| `remove_shadow_strength` | integer | No | `0` | `0` to `20` | Uneven lighting removal (0=off) |
| `min_confidence` | number | No | `0.4` | `0` to `1` | Minimum confidence (0.0-1.0) |
| `text_only` | boolean | No | `false` |  | Return only text lines (list of strings) |
| `include_bboxes` | boolean | No | `true` |  | Include x1,y1,x2,y2 in output |
| `include_polygons` | boolean | No | `false` |  | Include 4-point polygon as flat list |
| `remove_page_numbers` | boolean | No | `true` |  | Remove likely page numbers near bottom |
| `dehyphenate` | boolean | No | `true` |  | Join hyphenated words across lines |
| `normalize_quotes` | boolean | No | `true` |  | Normalize common quotation marks and dashes |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.0011 per API unit.
- **1 API unit = 1 request with up to 4 seconds of processing.** A request that takes longer uses one unit per started block of 4 seconds (for example, 10 seconds of processing uses 3 units, $0.0033).
- `autotune` (on by default) tries several parameter combinations, which takes longer; large or heavily preprocessed images also take longer and can use more units.
- **Example cost**: the example request took 8.46 seconds of processing, which is 3 units, $0.0033.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/text-extraction-from-images-zsxkib-easyocr`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 2 seconds and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/text-extraction-from-images-zsxkib-easyocr/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
      "version": "dd57bc29a831856d26d8a1b5a984d3dda62f85224e70a609f14fc04fd306e47e",
      "input": {
        "image": "https://blog.api.market/wp-content/uploads/2026/10/easyocr-input-api-market.webp",
        "languages": "en",
        "text_only": false,
        "preprocessing": true,
        "include_bboxes": true,
        "min_confidence": 0.25,
        "include_polygons": false
      }
    }'
```

Response (201 Created):
```json
{
  "id": "nareybzez1rgc0d1d26anecpt8",
  "version": "dd57bc29a831856d26d8a1b5a984d3dda62f85224e70a609f14fc04fd306e47e",
  "status": "starting",
  "created_at": "2026-10-23T11:37:09.328Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/text-extraction-from-images-zsxkib-easyocr/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "nareybzez1rgc0d1d26anecpt8",
  "status": "succeeded",
  "output": {
    "markdown": "URL of the extracted_text.md file",
    "metadata": "{\n  \"total_regions\": 14,\n  \"avg_confidence\": 0.837,\n  \"languages_used\": [\n    \"en\"\n  ],\n  \"preprocessing_applied\": true,\n  \"include_bboxes\": true,\n  \"include_polygons\": false,\n  \"text_only\": false,\n  \"regions\": [\n    {\n      \"text\": \"THE VELVETEEN\",\n      \"confidence\": 0.7319959206050128,\n      \"x1\": 99,\n      \"y1\": 0,\n      \"x2\": 657,\n      \"y2\": 41\n    },\n    {\n      \"text\": \"48 _\",\n      \"confidence\": 0.5110713290703586,\n      \"x1\": 339,\n      \"y1\": 1069,\n      \"x2\": 411,\n      \"y2\": 1117\n    }\n  ]\n}"
  },
  "error": null,
  "created_at": "2026-10-23T11:37:09.328Z",
  "started_at": "2026-10-23T11:39:16.227Z",
  "completed_at": "2026-10-23T11:39:24.684Z"
}
```

`output` is an object: `markdown` is the URL of a Markdown file (shown as a placeholder above) with the extracted text, and `metadata` is a JSON string with `total_regions`, `avg_confidence`, the settings used and a `regions` list (each region's `text`, `confidence` and, when enabled, its box or polygon). The `regions` list above is shortened.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `image` or a `languages` value that is not in the list.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/text-extraction-from-images-zsxkib-easyocr";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "dd57bc29a831856d26d8a1b5a984d3dda62f85224e70a609f14fc04fd306e47e", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 2000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
    "image": "https://blog.api.market/wp-content/uploads/2026/10/easyocr-input-api-market.webp",
    "languages": "en",
    "text_only": false,
    "preprocessing": true,
    "include_bboxes": true,
    "min_confidence": 0.25,
    "include_polygons": false
  }).then((output) => console.log(output));
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/text-extraction-from-images-zsxkib-easyocr"


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": "dd57bc29a831856d26d8a1b5a984d3dda62f85224e70a609f14fc04fd306e47e", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])


def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 2
    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"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")


print(create_and_wait_for_prediction({
    "image": "https://blog.api.market/wp-content/uploads/2026/10/easyocr-input-api-market.webp",
    "languages": "en",
    "text_only": False,
    "preprocessing": True,
    "include_bboxes": True,
    "min_confidence": 0.25,
    "include_polygons": False
}))
```

## FAQ
- **Which languages can it read?**
  - Choose `auto`, a preset (`en`, `es`, `fr`, `de`, `it`, `pt` or a combination), or set `languages` to `custom` and list codes in `custom_languages`, comma-separated.
- **How do I get text positions?**
  - Keep `include_bboxes` on for `x1`, `y1`, `x2`, `y2` per region, and turn on `include_polygons` for a 4-point polygon.
- **How do I read the metadata?**
  - `metadata` is a JSON string. Parse it to get `regions`, `total_regions` and `avg_confidence`.
- **How can I make requests faster?**
  - Turn off `autotune` and preprocessing steps you do not need. Fewer seconds of processing means fewer units.
- **What does one request cost?**
  - One unit ($0.0011) covers up to 4 seconds of processing. The example took 8.5 seconds, so it used 3 units, $0.0033.

## Contact Us
If you have any questions, reach out to us through the chat on the bottom right of the page. You can also email our support team at hello@magicapi.com.


Extract text with bounding boxes and confidence scores from images using EasyOCR, with optional preprocessing for scans. Pay as you go, no monthly fee.