# Image to Text OCR - Extract Text from Images & PDFs (`zenomastro/image-ocr-text-extractor`) Actor

Extract text from images, screenshots and scanned PDFs with OCR in 100+ languages. Returns plain text, Markdown, word confidence and bounding boxes per image or page. Bulk input from URLs, datasets or CSV. Failed downloads are not charged.

- **URL**: https://apify.com/zenomastro/image-ocr-text-extractor.md
- **Developed by:** [Rosario Vitale](https://apify.com/zenomastro) (community)
- **Categories:** AI, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 321 total users, 122 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 image ocrs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Why use this Actor?

Extract text from images, screenshots and scanned PDFs with OCR in 100+ languages. Returns plain text, Markdown, word confidence and bounding boxes per image or page. Bulk input from URLs, datasets or CSV. Failed downloads are not charged.

### Features

- **Image URLs** — Direct HTTP/HTTPS image URLs to process. Can be combined with documentUrls.
- **Languages** — OCR languages. Use Tesseract codes such as eng, ita, deu, fra, spa or chi_sim; common forms like en, it, English or eng+ita are converted automatically. Unknown values are skipped with a warning instead of failing the run. Up to 8 languages.
- **Preprocessing** — Image preprocessing strategy before OCR.
- **Page segmentation** — Tesseract page-layout assumption.
- **Include word-level data** — Add per-word confidence and bounding boxes. Same as Layout detail = "Words with boxes".
- **Layout detail** — Adds the layout to each result: lines, paragraphs or words, each with text, confidence, a pixel box (bbox) and a 0–1 box (bboxNorm) that does not depend on image size. Useful for tables, forms and highlighting. "Include word-level data" still works and equals "Words with boxes".
- **Max image size (MB)** — Reject images larger than this limit to prevent runaway memory use.
- **Download timeout (seconds)** — Maximum time allowed for each image download.
- **Download retries** — Retry transient download failures with exponential backoff.
- **Image or scanned PDF URLs** — Public HTTP/HTTPS image or PDF URLs. PDFs are rasterized page by page before OCR. Also accepted: pdfUrls (the input name of PDF to Structured Data).
- **Images or PDFs as base64** — For files that are not online: base64 strings or data URIs (data:image/png;base64,...), one per file, up to 100. Size limits are the same as for URLs. Results have sourceType "base64" and sourceKey "base64:1", "base64:2"…
- **Include Markdown** — Add Markdown text; PDF pages are labeled with page headings.

### Use cases

- Scanned document ocr.
- Screenshot text extraction.
- Pdf digitization.
- Searchable text and rag preparation.

### Related tools

- [Audio & Video to Text - Whisper Transcription API](https://apify.com/zenomastro/audio-video-to-text)
- [YouTube Transcript Scraper - Subtitles, SRT & RAG](https://apify.com/zenomastro/youtube-transcript-reliable)
- [Website Screenshot API - Full Page PNG, JPEG & PDF](https://apify.com/zenomastro/website-screenshot-pro)

### Example input

```json
{
  "languages": [
    "eng"
  ],
  "preprocessMode": "auto",
  "segmentationMode": "auto",
  "includeWords": false,
  "outputDetail": "text",
  "maxImageSizeMb": 20
}
```

### Pricing & cost control

The primary event costs **$0.005000 per image ocr** (about **$5.00 per 1,000** successful primary events).
Only successful primary events are intentionally billed by this Actor; summary/status rows add context without adding primary-event charges.

Use the bounded input limits and filters to keep both event charges and platform usage predictable.

### FAQ

**What is this Actor for?**\
It is designed for scanned document OCR, screenshot text extraction, PDF digitization.

**Can I run it on a schedule?**\
Yes. You can schedule Actor runs on Apify and send the resulting dataset into automations, webhooks, storage, or downstream APIs.

**How do I control cost and run size?**\
Use the input limits and filters shown in the Actor input form. The Actor applies bounded defaults and hard caps so large jobs remain predictable.

### Pricing at a glance

| | Price per 1,000 OCR'd images or PDF pages |
|---|---:|
| **This Actor** | **$5.00** |
| Median of 8 comparable Apify Store Actors (October 2026) | $6.50 |

That is about **23% below the median per-result price** for this task in Apify Store.

**Paid Apify plans pay less per image or page:** Bronze $4.50, Silver $4.25, Gold and higher **$4.00** per 1,000.

**From 16 October 2026, Apify platform usage (compute, storage, data transfer) is included** — you pay only the result price plus a small run start fee per GB of run memory (exact live amounts on the Pricing tab). No surprise compute bill, even on long runs.

Use the run's *maximum charge* setting to cap spending — the Actor stops cleanly when the limit is reached.

### Use it from AI agents (MCP) and code

**AI agents** — Claude, ChatGPT, Cursor, VS Code, n8n AI agents and any MCP client can run this Actor through the official Apify MCP server: add `https://mcp.apify.com?tools=zenomastro/image-ocr-text-extractor` to your client. Then just ask, for example:

> *"Extract the text from these scanned invoices (Italian and English) and flag low-confidence pages."*

The agent fills the input from the field descriptions and receives clean JSON it can reason over.

**API** — one HTTP call runs the Actor and returns the results directly:

```bash
curl -X POST "https://api.apify.com/v2/acts/zenomastro~image-ocr-text-extractor/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"imageUrls": ["https://tesseract.projectnaptha.com/img/eng_bw.png"], "languages": ["eng"], "includeWords": false, "includeMarkdown": true, "retries": 1}'
```

The same works from the Apify Python/JavaScript clients, Make, n8n, Zapier, LangChain and LlamaIndex integrations, or on a schedule.

Extract text from images, screenshots, scans, receipts, labels, forms, and photos with a robust OCR pipeline built for Apify.

This Actor uses Tesseract OCR plus optional image preprocessing, automatic orientation handling, bounded retries, download timeouts, input limits, confidence scores, and optional word-level bounding boxes. It is designed for production workflows where predictable failures and structured output matter as much as raw OCR accuracy.

### Why use this Image OCR Actor?

- **Reliable downloads** with retry and timeout controls.
- **Automatic preprocessing** for contrast, grayscale normalization, and sharpening.
- **Orientation recovery** for suspicious portrait/rotated images.
- **100+ Tesseract languages** and multilingual combinations. Codes like `en`, `it` or names like `English` are converted automatically, and an unknown language never fails the run.
- **Batch processing** of up to 1,000 direct URLs per run, or up to 5,000 from CSV/JSON manifests, public Google Sheets or an Apify Dataset. Larger lists are trimmed and reported, never a failed run.
- **Scanned PDF OCR** page by page at the same per-page price as images, with a document summary and low-confidence page list.
- **PDF tables and metadata** (optional, no extra charge): rows of cells from digital PDFs and the document's title, author, dates and page size.
- **All common image formats**: PNG, JPEG, WebP, GIF, TIFF, BMP, SVG and iPhone **HEIC/HEIF** photos (converted automatically).
- **Word-level output** with confidence and bounding boxes when requested.
- **Cost protection** through image-size and input-count limits.
- **Structured JSON output** ready for APIs, RAG pipelines, search, spreadsheets, and automation.

### How to use it

1. Add direct HTTP/HTTPS image URLs (`imageUrls`) and/or scanned PDF URLs (`documentUrls`), or point the Actor at a CSV/JSON/Google Sheets list (`sourceListUrls`) or an Apify Dataset (`inputDatasetId`).
2. Select the OCR languages, for example `eng`, `ita`, or `eng+ita` (`en`, `it`, `English` also work).
3. Keep **Auto preprocessing** for most photos and screenshots.
4. Optionally enable word-level data when you need positions or per-word confidence.
5. Run the Actor and download the Dataset as JSON, CSV, Excel, or another supported format.

### Input

Main fields:

- `imageUrls` — direct HTTP/HTTPS image URLs.
- `documentUrls` — image or scanned PDF URLs; PDFs are rasterized page by page (`maxPdfPages`, `pdfDpi`).
- `sourceListUrls` — CSV, JSON, plain-text or public Google Sheets lists of URLs.
- `inputDatasetId` / `datasetUrlField` — read URLs from another Actor's Dataset.
- `languages` — Tesseract language codes (ISO codes and language names are converted).
- `preprocessMode` — `auto`, `none`, `grayscale`, or `threshold`.
- `segmentationMode` — automatic layout, single text block, or sparse text.
- `includeWords` — adds per-word confidence and bounding boxes.
- `maxImageSizeMb` — rejects oversized images before they consume excessive memory.
- `requestTimeoutSecs` — maximum download time per image.
- `retries` — bounded retries with exponential backoff.
- `extractTables` — PDF tables as rows of cells, for pages read from the PDF's text layer (off by default).
- `extractMetadata` — PDF title, author, dates, page size and more on the document summary (off by default).

Example:

```json
{
  "imageUrls": ["https://example.com/document.png"],
  "languages": ["eng"],
  "preprocessMode": "auto",
  "includeWords": true,
  "requestTimeoutSecs": 30,
  "retries": 2
}
```

### Output

Each image produces one Dataset item (`recordType: "ocr"`). Each PDF produces one `ocr` item per page plus one `document_summary` item with the combined Markdown, average confidence and the list of low-confidence pages. Anything that could not be processed is returned as a `recordType: "error"` item with a readable message, and the run keeps going:

```json
{
  "url": "https://example.com/document.png",
  "success": true,
  "language": "eng",
  "confidence": 94.2,
  "text": "Recognized text...",
  "wordCount": 42,
  "characterCount": 256,
  "processingMs": 830,
  "image": { "width": 1600, "height": 900, "format": "png" }
}
```

When `includeWords=true`, the result also contains individual words with confidence and bounding boxes.

### Output fields

| Field | Description |
|---|---|
| `recordType` | `ocr`, `document_summary` or `error` |
| `url` | Original image URL |
| `success` | Whether OCR completed successfully |
| `language` | OCR language combination |
| `confidence` | Overall Tesseract confidence |
| `text` | Recognized text |
| `wordCount` | Number of recognized words |
| `characterCount` | Number of output characters |
| `pageNumber` / `pageCount` | PDF page position (null for single images) |
| `lowConfidence` | `true` when confidence is below `minConfidence` |
| `processingMs` | Processing time for the image |
| `image` | Source width, height, and detected format |
| `words` | Optional per-word confidence and bounding boxes |
| `tables` | With `extractTables`: rows of cells of a PDF page read from its text layer |
| `tablesError` | Why `tables` is missing on a page (its text is still complete) |
| `metadata` | With `extractMetadata`: PDF metadata, on the `document_summary` row |
| `error` | Clean error message when processing fails |

### PDF tables and metadata

Two optional switches for PDFs. Both are off by default and add no charge: tables go into the page rows you already get, metadata into the free `document_summary` row.

**Extract tables** (`extractTables: true`). Pages read from the PDF's own text layer (`textSource: "text_layer"`, typical for digital PDFs) also get `tables`: the page's rows from top to bottom, each split into cells by the position of the text. A row with a single cell is a plain line of text. With Include Markdown on, a page that has a table gets an `### Extracted table` section in its Markdown and in the document summary. Detection is position-based, the same method as PDF to Structured Data: very good for clean, grid-like tables, approximate for complex layouts. Scanned pages read with OCR get no `tables` (use Layout detail for their line or word boxes). If a page's layout cannot be read, the page keeps its full text and gets a short `tablesError` note instead.

```json
{
  "recordType": "ocr",
  "pageNumber": 1,
  "textSource": "text_layer",
  "text": "Product      Units    Price\nWidget A     120      9.99",
  "tables": [["Product", "Units", "Price"], ["Widget A", "120", "9.99"]],
  "markdown": "## Page 1\n\n...\n\n### Extracted table\n\n| Product | Units | Price |\n| --- | --- | --- |\n| Widget A | 120 | 9.99 |"
}
```

**Include PDF metadata** (`extractMetadata: true`). The PDF's `document_summary` row gets `metadata`:

```json
"metadata": {
  "title": "Price list 2026",
  "author": "Jane Doe",
  "subject": null,
  "keywords": "prices, catalog",
  "creator": "Microsoft Word",
  "producer": "Microsoft: Print To PDF",
  "creationDate": "2026-03-02T09:15:00Z",
  "modDate": "2026-03-02T09:15:00Z",
  "pageCount": 4,
  "encrypted": false,
  "pageSize": { "width": 595.276, "height": 841.89, "unit": "pt", "name": "A4" },
  "pdfVersion": "1.7"
}
```

Dates are converted to ISO 8601 (UTC) when the PDF's date can be read; otherwise the PDF's own text is kept. Fields the PDF does not have are `null`. `pageSize` is the size of the first page, in points.

### Moving from PDF to Structured Data?

Your input works here unchanged: just change the Actor name. `pdfUrls`, `maxPages` (0 = all pages, up to 100 per PDF), `maxPdfSizeMb`, `extractTables`, `extractMetadata`, `includeMarkdown`, `requestTimeoutSecs` and `retries` are all accepted. What is different: results come as one row per page plus one `document_summary` row per PDF (with the combined Markdown and the metadata) instead of one row per PDF; metadata is added only with `extractMetadata: true` (it was on by default there); without `maxPages`, up to 25 pages per PDF are read; scanned pages are read with OCR instead of coming back empty; and each page is billed as one OCR result.

### Pricing and cost control

The Actor uses pay-per-event pricing and charges only for successfully processed images. Failed downloads or OCR attempts are returned with `success: false` and are not intentionally billed as successful OCR events.

To keep runs predictable, the Actor limits the number of images per run, rejects excessively large inputs, uses bounded retries, and resizes extremely large images before OCR.

### Accuracy tips

Use `auto` preprocessing first. For already-clean screenshots, `none` can preserve the original pixels. For difficult high-contrast scans, try `threshold`. If the image contains scattered labels rather than paragraphs, use `sparse_text` segmentation.

OCR accuracy depends on resolution, compression, lighting, blur, font style, and language selection. No OCR engine can guarantee perfect recognition on every image, so use confidence scores when downstream decisions are sensitive.

### FAQ and support

**Which languages can I use?** Any Tesseract language (`eng`, `ita`, `deu`, `fra`, `spa`, `por`, `chi_sim`, `jpn`, `ara`, …), up to 8 per run. Two-letter codes (`en`, `de`), locale tags (`zh-TW`, `pt-BR`) and English names (`Italian`) are converted for you; unknown values are skipped with a warning and the run falls back to English instead of failing.

**What happens when a URL is broken, private or too large?** That item is returned with `recordType: "error"` and a clear message, it is not billed as an OCR result, and the rest of the batch continues. An unreachable manifest or an empty input also produces an error item instead of a failed run.

**Does it work with scanned PDFs?** Yes. Each page is rendered (default 160 DPI, up to 300) and OCR'd one page at a time, so long documents do not exhaust memory. Use `maxPdfPages` to cap cost per document.

**How is it priced?** One OCR event per image or per PDF page plus a small run start fee — from 16 October 2026 Apify platform usage is included, so there is no separate compute bill. You can cap spending with the run's maximum charge; the Actor stops cleanly when the limit is reached.

This Actor processes image URLs supplied by the user. Make sure you have the right to process the images and that your use complies with applicable laws and the source site's terms.

For reproducible bug reports, provide the run ID, input settings, and a non-sensitive sample image URL. Never include API tokens, passwords, or private credentials in issue reports.

### Extended capabilities

- OCR images, screenshots, scans, and PDFs with preprocessing, orientation recovery, confidence, words, bounding boxes, and Markdown.
- Process PDFs page by page with explicit page metadata and bounded file/image sizes.
- Accept direct URLs or read file URLs from an Apify Dataset field for native Actor-to-Actor pipelines.

# Changelog

This Actor's version history is a separate document: https://apify.com/zenomastro/image-ocr-text-extractor/changelog.md

# Actor input Schema

## `imageUrls` (type: `array`):

Direct HTTP/HTTPS image URLs to process. Can be combined with documentUrls.

## `languages` (type: `array`):

OCR languages. Use Tesseract codes such as eng, ita, deu, fra, spa or chi_sim; common forms like en, it, English or eng+ita are converted automatically. Unknown values are skipped with a warning instead of failing the run. Up to 8 languages.

## `preprocessMode` (type: `string`):

Image preprocessing strategy before OCR.

## `segmentationMode` (type: `string`):

Tesseract page-layout assumption.

## `includeWords` (type: `boolean`):

Add per-word confidence and bounding boxes. Same as Layout detail = "Words with boxes".

## `outputDetail` (type: `string`):

Adds the layout to each result: lines, paragraphs or words, each with text, confidence, a pixel box (bbox) and a 0–1 box (bboxNorm) that does not depend on image size. Useful for tables, forms and highlighting. "Include word-level data" still works and equals "Words with boxes".

## `maxImageSizeMb` (type: `integer`):

Reject images larger than this limit to prevent runaway memory use.

## `requestTimeoutSecs` (type: `integer`):

Maximum time allowed for each image download.

## `retries` (type: `integer`):

Retry transient download failures with exponential backoff.

## `documentUrls` (type: `array`):

Public HTTP/HTTPS image or PDF URLs. PDFs are rasterized page by page before OCR. Also accepted: pdfUrls (the input name of PDF to Structured Data).

## `imagesBase64` (type: `array`):

For files that are not online: base64 strings or data URIs (data:image/png;base64,...), one per file, up to 100. Size limits are the same as for URLs. Results have sourceType "base64" and sourceKey "base64:1", "base64:2"…

## `includeMarkdown` (type: `boolean`):

Add Markdown text; PDF pages are labeled with page headings.

## `maxDocumentSizeMb` (type: `integer`):

Maximum downloaded PDF/document size. Also accepted: maxPdfSizeMb.

## `maxPdfPages` (type: `integer`):

Maximum rasterized OCR pages per PDF. Also applies to multi-page TIFF files. Also accepted: maxPages, where 0 means all pages up to the maximum of 100.

## `pdfDpi` (type: `integer`):

Raster resolution for scanned PDF pages. Higher improves small text but costs more memory/time.

## `pdfTextMode` (type: `string`):

Digital PDFs already contain their text. Auto reads it directly (exact and fast) and runs OCR only on pages without usable text, such as scans. Choose OCR every page if a PDF's text layer is wrong. Each result row says textSource "text_layer" or "ocr".

## `minTextLayerChars` (type: `integer`):

In Auto mode, a PDF page whose text layer has fewer letters and digits than this is treated as scanned and read with OCR.

## `extractTables` (type: `boolean`):

PDF pages read from their text layer (textSource "text_layer") also get tables: the page's rows, top to bottom, split into cells by text position, as \[\[cell, ...], ...]. A row with one cell is a plain line. With Include Markdown, the Markdown adds the rows as a table. Same method as PDF to Structured Data: best for clean, grid-like tables. Pages read with OCR (scans) get no tables. No extra charge.

## `extractMetadata` (type: `boolean`):

Adds metadata to each PDF's document_summary row: title, author, subject, keywords, creator, producer, creation and modification dates (ISO 8601), page count, encryption, page size and PDF version. Missing values are null. No extra charge.

## `inputDatasetId` (type: `string`):

Optional Apify dataset whose items contain image or PDF URLs. Useful for OCR pipelines without copying URLs manually.

## `datasetUrlField` (type: `string`):

Field name read from each input dataset item, e.g. url, imageUrl or fileUrl.

## `maxDatasetItems` (type: `integer`):

Hard cap on input dataset items processed per run.

## `sourceListUrls` (type: `array`):

Optional public manifest URLs containing image/PDF URLs. Supports CSV, JSON arrays/objects, newline text, and public Google Sheets (automatically read via CSV export).

## `sourceListUrlField` (type: `string`):

Column/object field containing file URLs, e.g. url, imageUrl or fileUrl. Common URL fields are auto-detected when possible.

## `maxSourceListItems` (type: `integer`):

Hard cap on URLs extracted from each external manifest.

## `minConfidence` (type: `number`):

Optional OCR confidence threshold. Results are never discarded; rows below the threshold are flagged lowConfidence for review.

## Actor input object example

```json
{
  "imageUrls": [
    "https://tesseract.projectnaptha.com/img/eng_bw.png"
  ],
  "languages": [
    "eng"
  ],
  "preprocessMode": "auto",
  "segmentationMode": "auto",
  "includeWords": false,
  "outputDetail": "text",
  "maxImageSizeMb": 20,
  "requestTimeoutSecs": 30,
  "retries": 2,
  "documentUrls": [],
  "imagesBase64": [],
  "includeMarkdown": true,
  "maxDocumentSizeMb": 50,
  "maxPdfPages": 25,
  "pdfDpi": 160,
  "pdfTextMode": "auto",
  "minTextLayerChars": 40,
  "extractTables": false,
  "extractMetadata": false,
  "inputDatasetId": "",
  "datasetUrlField": "url",
  "maxDatasetItems": 100,
  "sourceListUrls": [],
  "sourceListUrlField": "url",
  "maxSourceListItems": 1000,
  "minConfidence": 0
}
```

# Actor output Schema

## `overview` (type: `string`):

Main fields of every result, ready to preview or export as CSV, Excel or JSON.

## `results` (type: `string`):

Every result with all fields, for APIs, AI agents and integrations.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "imageUrls": [
        "https://tesseract.projectnaptha.com/img/eng_bw.png"
    ],
    "languages": [
        "eng"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zenomastro/image-ocr-text-extractor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "imageUrls": ["https://tesseract.projectnaptha.com/img/eng_bw.png"],
    "languages": ["eng"],
}

# Run the Actor and wait for it to finish
run = client.actor("zenomastro/image-ocr-text-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "imageUrls": [
    "https://tesseract.projectnaptha.com/img/eng_bw.png"
  ],
  "languages": [
    "eng"
  ]
}' |
apify call zenomastro/image-ocr-text-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zenomastro/image-ocr-text-extractor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/kzp5Q8SUwTlVMTk12/builds/YvrdALCSh6DEMPvFr/openapi.json