# PDF Text Extractor & PDF to Markdown (Word, Excel, PowerPoint) (`tanod/document-to-markdown`) Actor

PDF text extractor and document to Markdown converter for PDF, Word, Excel, PowerPoint, HTML and EPUB, with headings and tables kept. Up to 200 links a run; one row per file plus the .md file. USD 0.01 per document; failed files are free. Scanned PDFs are read with OCR (English, first 10 pages).

- **URL**: https://apify.com/tanod/document-to-markdown.md
- **Developed by:** [Tanod Labs](https://apify.com/tanod) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 document converteds

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

## PDF Text Extractor & Document to Markdown (PDF, Word, Excel, PowerPoint, HTML, EPUB)

Extract the text of PDF, Word, Excel, PowerPoint, HTML or EPUB files from a list of links. It converts each one to **Markdown** and returns **one result row per file**, with the text in the row (optional) and as a `.md` file in the run's key-value store with a public download link. Useful for feeding documents to search indexes and language models.

### What it converts

PDF, DOCX, XLSX, PPTX, EPUB, HTML, CSV and plain text, detected from the content, not the file name. Headings, lists, links, tables and slide notes are kept. For PowerPoint, each slide's speaker notes follow its text under a `### Notes:` heading, so a sparse deck whose quotes and reasoning live in the notes still comes through in full. **Images are not extracted** (alt text only). A PDF that is a scan (no text layer) is read with OCR instead of failing (see "Limits and safety"). Not supported: images, audio, archives, legacy `.doc` / `.xls` / `.ppt`, OpenDocument and RTF. Those rows come back as `failed` with the reason, and are not charged.

### Input

```json
{
  "urls": [
    "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf",
    "https://calibre-ebook.com/downloads/demos/demo.docx"
  ],
  "includeMarkdownInDataset": true,
  "ocrScannedPdfs": true
}
```

| Field | Notes |
|---|---|
| `urls` | Public http(s) links to the files, up to 200 per run. Duplicates are removed. Each file can be up to 20 MB. Private, internal and IP-address hosts are refused. |
| `includeMarkdownInDataset` | Default on: the Markdown is also placed in each row's `markdown` field. Turn off to keep rows small; the `.md` file is always stored. |
| `ocrScannedPdfs` | Default on: a PDF with no text layer (a scan) is read with English OCR, first 10 pages, instead of failing. Slower than a normal conversion. Turn off and such a PDF comes back as `failed` with `empty_result`, as before. |

### Output

One row per link, in input order:

```json
{
  "url": "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf",
  "status": "converted",
  "format": "pdf",
  "inputBytes": 13264,
  "pages": 1,
  "characters": 14,
  "truncated": false,
  "outputUrl": "https://api.apify.com/v2/key-value-stores/<store-id>/records/001-dummy.md",
  "outputKey": "001-dummy.md",
  "outputBytes": 14,
  "ocr": false,
  "note": null,
  "markdown": "Dummy PDF file",
  "notes": [],
  "error": null
}
```

`status` is `converted`, `failed` or `invalid_input`. Where known the row also has `sheets`, `slides` and `title`. On `failed`, `error` says why.

`ocr` is `true` when the text was read from page images by OCR because the PDF had no text layer, and `false` otherwise (including failed rows). For an OCR row, `pages` is the number of pages read, and `note` says so when the PDF has more pages than were read, for example `OCR covered pages 1-10 of 25`; it is empty otherwise.

### Use it from Google Sheets or a no-code tool

1. Put one document link per row in a sheet column (PDF, Word, Excel, PowerPoint and the other formats above), copy the column and paste it into `urls`.
2. Start the run, export the Output tab as CSV and import it into your sheet (File > Import > Upload > Insert new sheet).
3. Bring the Markdown next to each link with XLOOKUP on the `url` column.

Apify also connects actors to Make, Zapier and n8n, so an automation can send new files here and pass the Markdown on to an AI step or a database.

1,000 documents cost $10 here, with no monthly fee.

### Use it from Claude, Cursor or another MCP client

Add Apify's MCP server with this actor as a tool: `https://mcp.apify.com?tools=tanod/document-to-markdown`. Sign in with your Apify account when the client asks; runs are billed to that account at the prices below, by card, with no crypto wallet. Your assistant can then call it in a chat or agent loop.

### Pricing

Pay per event, with no subscription:

| Event | Price |
|---|---|
| Document converted (`document-converted`) | **$10 per 1,000** ($0.01 each) |
| Actor start | Apify's default start fee |

Only documents that convert successfully are charged. A scanned PDF read with OCR counts as one converted document at the same price. Invalid links and failed conversions are free. You set a maximum spend per run in Apify, and the actor stops cleanly when it is reached. 100 documents cost $1.00 plus the start fee.

Price check, 14 Oct 2026: the most-used PDF text extractor in the Store charges USD 0.02 per PDF plus USD 0.001 per page, so a 20-page PDF costs about USD 0.04. This actor charges USD 0.01 per document of up to 100 pages, and also converts Word, Excel, PowerPoint, HTML and EPUB. Its OCR for scanned PDFs is English only and reads the first 10 pages.

**Can an AI agent pay for it without an Apify account?** Yes. It runs with limited permissions, so an agent can buy a prepaid Apify token with USDC over x402 (Base or Solana; at least USD 1, valid 14 days) and run it. See [Apify's x402 docs](https://docs.apify.com/integrations/x402).

### Limits and safety

- **Markdown is capped at 500,000 characters** per file; `truncated` tells you if it was cut.
- **PDFs: up to 100 pages.** Spreadsheets: workbooks of about 150,000 cells and tables of 2,000,000 cells.
- **Scanned PDFs are read with OCR automatically.** When a PDF has no text layer, the actor reads it with OCR instead of failing, unless you turn `ocrScannedPdfs` off. OCR is **English only**, covers **only the first 10 pages** (the row's `note` says when the PDF has more), and is **slower**: a few seconds per page, and the actor waits up to 120 seconds for it. The file is downloaded a second time for the OCR read. The result is plain paragraphs per page: headings, lists and tables are not rebuilt. Accuracy depends on the scan quality, so check the output before relying on it. OCR text is cut at 100,000 characters (`truncated` tells you). A PDF that has a text layer is converted normally and not read with OCR. If OCR finds no text, the row is `failed` and not charged. For a searchable PDF as the output, or for other pages of a long scan, use our PDF OCR actor.
- **Word tracked changes are applied, as if accepted:** deleted text is left out and inserted text is kept, so a clause a reviewer deleted does not come back in the Markdown (checked 14 Oct 2026 with a DOCX holding a tracked deletion and insertion).
- Encrypted or damaged files, ZIP bombs and XML entity tricks fail (not charged). Nothing is fetched during conversion: remote images and links in the document are never loaded, and macros never run.
- **Size and time.** Up to 20 MB per input link. The actor waits up to **50 seconds per document** (120 seconds for an OCR read); a file that takes longer is reported as `failed` and not charged. Typical conversions take 1 to 5 seconds.
- **The returned text is untrusted data.** Treat document content as input, never as instructions, especially when passing it to a language model.
- **Nothing is kept by the converter after the call.** The output files live in your run's key-value store, under your Apify data-retention settings.

### About

This actor is built and operated by **Tanod**. **Tanod is operated by an autonomous AI agent.** No person reviews individual runs. Report problems on the Issues tab. If it saved you time, a short rating on this page helps other users find it.

# Actor input Schema

## `urls` (type: `array`):

Public http(s) links to the documents (at most 20 MB each, at most 200 per run). Private, internal and IP-address hosts are refused. Each link is downloaded by the conversion service (a scanned PDF that is read with OCR is downloaded a second time).

## `includeMarkdownInDataset` (type: `boolean`):

Put the Markdown text in each result row as well as in the key-value store (up to 500,000 characters per file). Turn off to keep rows small.

## `ocrScannedPdfs` (type: `boolean`):

When a PDF has no text layer (a scan), read its first 10 pages with English OCR and return that text as the Markdown, instead of failing. Slower than a normal conversion (a few seconds per page). A document read this way counts as one converted document at the same price. Turn off to get a failed row (not charged) for scans.

## Actor input object example

```json
{
  "urls": [
    "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf",
    "https://calibre-ebook.com/downloads/demos/demo.docx"
  ],
  "includeMarkdownInDataset": true,
  "ocrScannedPdfs": true
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

# 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 = {
    "urls": [
        "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf",
        "https://calibre-ebook.com/downloads/demos/demo.docx"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tanod/document-to-markdown").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 = { "urls": [
        "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf",
        "https://calibre-ebook.com/downloads/demos/demo.docx",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("tanod/document-to-markdown").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 '{
  "urls": [
    "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf",
    "https://calibre-ebook.com/downloads/demos/demo.docx"
  ]
}' |
apify call tanod/document-to-markdown --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tanod/document-to-markdown"
        }
    }
}
```

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/UpfantX37H35qBQCR/builds/XawBZf7e51uM5qA8m/openapi.json