Document to Markdown (Apify Actor)

Convert PDFs, DOCX, PPTX, XLSX and HTML to clean Markdown for LLMs and RAG: page numbers, heading-aware chunks with page refs, and a per-document quality report that flags missing text.

apify.com에서 보기

호스팅형 MCP 서버

npx add-mcp 'https://mcp.apify.com?tools=flyingkiwi/document-to-markdown'

Claude Code, Codex, Cursor 등에 설치됩니다

문서

PDF to Markdown & Document Converter: DOCX, PPTX, XLSX, OCR (`flyingkiwi/document-to-markdown`) Actor

Convert PDF to Markdown, plus Word (DOCX), PowerPoint (PPTX), Excel (XLSX), HTML and EPUB. Paste a URL, a Google Drive, Dropbox or SharePoint file or folder link, or upload files. Clean Markdown for LLMs and RAG, with OCR for scanned PDFs, tables and chunks. Pay per document.

URL: https://apify.com/flyingkiwi/document-to-markdown.md
Developed by: Pete Buckthought (community)
Categories: AI, Developer tools, Automation
Stats: 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
User rating: No ratings yet

Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 section below.

Each client library has reference documentation the quickstart does not restate: JavaScript/TypeScript (npm install apify-client) and Python (pip install apify-client).

README

PDF to Markdown & Document Converter (DOCX, PPTX, XLSX, OCR)

Convert PDF to Markdown in one step, and Word (DOCX), PowerPoint (PPTX), Excel (XLSX), HTML, EPUB, CSV and Jupyter files too. Document to Markdown is a PDF and document converter for LLMs and RAG: you get clean Markdown with headings, lists and tables kept, plus page numbers.

The Markdown is ready for LLM prompts, RAG pipelines, vector databases and AI agents. Give it one URL, a list of URLs, Google Drive / Dropbox / OneDrive / SharePoint share links, a whole shared folder link (every supported file in it, subfolders included), or upload files. You get back Markdown plus page counts, word counts, a quality report and optional heading-aware chunks. Scanned PDF pages can be read with optional OCR. You pay per document, not per minute.

For AI agents: input {"url": "https://..."} → output Markdown (dataset row markdown, and the run's OUTPUT record for single-document runs). See Use it from an AI agent (MCP).

What does Document to Markdown do?

Gets your documents from public URLs, cloud share links (Google Drive, Google Docs/Sheets/Slides, Dropbox, OneDrive, SharePoint), whole shared folders (Google Drive, Dropbox, SharePoint / OneDrive for Business), files you upload, or private URLs with your own request headers.
Detects the real file type from the file's contents, not just its extension or the server's headers.
Converts to Markdown. It keeps headings, lists and tables from DOCX, PPTX, XLSX and HTML. PDFs are converted page by page, with  markers so you can cite page numbers, and section headings are detected from font size and weight.
Reads scanned PDF pages with OCR (optional, off by default). Only pages with no text layer are sent to a vision AI model.
Reports quality for every document: text coverage, empty and scanned pages, tables found, and plain-English warnings when content may be missing.
Optionally splits the Markdown into chunks sized for embeddings. It starts a new chunk at each heading, avoids cutting mid-sentence where it can, adds overlap, and records the PDF page each chunk starts on.
Saves results to a dataset you can export as JSON, CSV or Excel, or read via the Apify API. You can also save each document as a .md file.

It is built on Microsoft's open-source MarkItDown (MIT licence) for Office/HTML formats, pdfminer.six and pdfplumber for PDF text and tables.

Why use it?

RAG and chatbots: turn manuals, policies, reports and slide decks into text your LLM can read.
AI agents: an agent can call this Actor through the Apify API or MCP and get Markdown back in one step.
Search and analytics: extract text from many documents at once without running your own conversion server.
Predictable cost: a flat price per document, with a small charge only for long documents (see Pricing).

Supported formats

Format	Extensions	Notes
PDF	`.pdf`	Page markers included. Headings detected from font size/weight (running headers and footers skipped). Ruled tables become Markdown tables. Scanned pages: turn on `ocr`, otherwise the quality report lists them.
Word	`.docx`	Headings, lists, tables. Legacy `.doc` is not supported.
PowerPoint	`.pptx`	One section per slide, including slide notes where present. Legacy `.ppt` is not supported.
Excel	`.xlsx`, `.xls`	One clean Markdown table per sheet: first row as header, empty rows/columns dropped, no `NaN` or `Unnamed` cells, dates as ISO dates.
Web pages	`.html`, `.htm`	Main content converted to Markdown. Navigation, sidebars, cookie banners and footers are stripped.
EPUB	`.epub`
CSV	`.csv`	Converted to a Markdown table.
Jupyter	`.ipynb`	Markdown and code cells.
Text	`.txt`, `.md`, `.json`, `.xml`	Passed through as text.

ZIP archives, images, audio and video are not processed.

How to use it

Click Try for free (or Start).
Paste a link (a file or a whole shared folder) into Document URL, add more under Document URLs, or use Upload files. Links need no extra step. If you upload, also pick the store you uploaded into under Key-value store with your uploads (see How do I upload files?).
Optional: turn on OCR scanned PDF pages if your PDFs are scans.
Optional: set Chunk size (for example 1500 characters) if you want ready-made chunks for embeddings.
Click Start and download the results from the Output tab.

Input examples

The simplest input (good for AI agents):

{ "url": "https://arxiv.org/pdf/1706.03762" }

A whole shared folder (every PDF, DOCX, PPTX, XLSX... inside, subfolders included):

{ "url": "https://drive.google.com/drive/folders/FOLDER_ID?usp=sharing", "maxFiles": 200 }

A batch with share links, OCR and chunks:

{
  "urls": [
    "https://arxiv.org/pdf/1706.03762",
    "https://drive.google.com/file/d/FILE_ID/view?usp=sharing",
    "https://www.dropbox.com/scl/fi/abc123/handbook.docx?rlkey=xyz&dl=0"
  ],
  "ocr": true,
  "chunkSize": 1500,
  "chunkOverlap": 200,
  "includeMarkdown": true,
  "saveMarkdownFiles": true
}

Main input options

Field	Default	What it does
`url`	–	One document URL or share link.
`urls`	–	More URLs or share links. Google Drive/Docs/Sheets/Slides, Dropbox, OneDrive and SharePoint links are turned into downloads automatically (share them as "anyone with the link").
`files`	–	Upload files from your computer. Pick the store they were uploaded into in `filesStore`. Via API: Apify key-value store record URLs (signed URLs work on their own).
`filesStore`	–	The key-value store your uploads are in (read-only access to that store only). With `files` empty, converts every document in the store (up to 1,000).
`maxFiles`	`500`	Folder links: convert at most this many supported files per folder (subfolders included).
`includeSubfolders`	`true`	Folder links: also convert files in subfolders. Each result has a `relativePath`.
`maxFolderDownloadMb`	`500`	Dropbox folder links only: Dropbox sends a folder as one ZIP of everything in it, so bigger folders are refused (link a subfolder or raise this).
`requestHeaders`	–	Optional headers such as `{"Authorization": "Bearer ..."}` for private URLs. Sent only to the host of each URL you give, never to redirects on other hosts. Stored encrypted.
`ocr`	`false`	Read scanned PDF pages with a vision AI model (paid add-on, see Pricing).
`ocrMaxPagesPerDocument`	`50`	Cap on OCR pages per document.
`ocrModel`	`google/gemini-2.5-flash`	Vision model used for OCR, via Apify's AI proxy.
`chunkSize`	`0` (off)	Split Markdown into chunks of about this many characters.
`chunkOverlap`	`200`	Characters repeated between chunks.
`includeMarkdown`	`true`	Include the full Markdown in each dataset row.
`saveMarkdownFiles`	`true`	Also save each document as a `.md` file in the run's key-value store, with a download link in the output (`markdownFileUrl`).
`pdfTables`	`true`	Add tables found in PDFs as Markdown tables (best for tables drawn with lines). Table text also stays in the page text, so tables add some duplicate words, and big PDFs convert about 2–3× slower. Set to `false` for plain text only.
`maxFileSizeMb`	`25`	Skip files larger than this.
`maxPagesPerDocument`	`300`	Skip documents longer than this, so a huge file can't surprise you with a big bill.
`requestTimeoutSecs`	`60`	Download timeout per file.
`maxConcurrency`	`3`	Documents processed in parallel.

Output example

{
  "url": "https://arxiv.org/pdf/1706.03762",
  "finalUrl": "https://arxiv.org/pdf/1706.03762",
  "fileName": "1706.03762.pdf",
  "format": "pdf",
  "title": "Attention Is All You Need",
  "pageCount": 15,
  "pageCountBasis": "pages",
  "wordCount": 5830,
  "charCount": 38426,
  "markdown": "<!-- page 1 -->\n\nProvided proper attribution is provided, Google hereby grants permission to\nreproduce the tables and figures in this paper ...",
  "chunks": [
    { "index": 0, "heading": null, "page": 1, "text": "Provided proper attribution is provided, ...", "charCount": 173 },
    ...
    { "index": 10, "heading": "3.2 Attention", "page": 3, "text": "### 3.2 Attention\n\nAn attention function can be described as mapping a query and a set of key-value pairs to an output, ...", "charCount": 542 }
  ],
  "quality": {
    "tablesFound": 0,
    "pagesWithText": 15,
    "textCoverage": 1.0,
    "emptyPages": [],
    "scannedPages": [],
    "ocrPages": [],
    "possibleContentLoss": false,
    "warnings": []
  },
  "markdownFileUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/attention-is-all-you-need-1a2b3c4d.md?signature=...",
  "status": "ok",
  "error": null,
  "convertedAt": "2026-10-27T20:04:00+00:00"
}

For a PDF with a scanned page and OCR off, quality looks like this, so you can catch silent content loss:

{
  "tablesFound": 0, "pagesWithText": 1, "textCoverage": 0.5,
  "emptyPages": [3], "scannedPages": [2], "ocrPages": [],
  "possibleContentLoss": true,
  "warnings": ["1 page(s) look scanned (an image, or text drawn as shapes) and have no text: 2. Turn on OCR to read them."]
}

textCoverage is the share of pages with content (text or images) that ended up with text. Blank pages don't count against it.

Files that can't be converted (not found, too large, unsupported type, password-protected) appear as rows with "status": "error" and a plain-English error. Failed files are not charged.

Converting a whole folder

Paste a shared folder link into url or urls. The Actor finds every supported file in the folder (and its subfolders, unless you turn includeSubfolders off) and converts each one into its own result row, with folderUrl and relativePath (for example Reports/2024/q1.pdf). Images, videos and other unsupported files are skipped and listed in the run's status message and in the FOLDER_SUMMARY record of the run's key-value store.

Folder link from	Works?	How
Google Drive (`drive.google.com/drive/folders/...`)	Yes	Google Docs, Sheets and Slides in the folder are exported as DOCX, XLSX and PPTX.
Dropbox (`dropbox.com/scl/fo/...`)	Yes	Dropbox only shares a folder as one ZIP of everything in it, so the whole folder is downloaded (up to `maxFolderDownloadMb`) and the supported files inside are converted.
SharePoint / OneDrive for Business (`...sharepoint.com/:f:/...`)	Yes	Only the supported files are downloaded.
OneDrive personal (`1drv.ms/f/...`, `onedrive.live.com`)	No	Microsoft now requires a sign-in to list these folders. Upload the files, or share from one of the services above.

The folder must be shared as "Anyone with the link can view". Private folders get a clear error and are not charged. Billing is the same as for single files: one document event per converted file (plus pages above 20 and OCR pages), nothing for skipped or failed files. Use maxFiles and your maximum cost per run to cap a big folder: the Actor checks the remaining budget before downloading each file and stops cleanly, telling you how many files were left.

Pricing

This Actor uses pay-per-event pricing. You only pay for documents that convert successfully:

Event	Price
Actor start	$0.003 per run
Document converted (includes up to 20 pages)	$0.003
Each page above 20	$0.001
OCR page (only when `ocr` is on, only scanned pages that were read)	$0.008

Examples: a 10-page DOCX costs $0.003. A 77-page PDF costs $0.003 + 57 × $0.001 = $0.06. 1,000 short documents cost about $3. A 10-page scanned PDF with OCR on costs $0.003 + 10 × $0.008 = $0.083.

OCR model usage is billed by Apify to your account at cost through its AI proxy, on top of the price above. With the default model this was about $0.001 per page in our tests. Text pages are never sent for OCR.

For PDFs and slide decks the page count is the real page or slide count. For other formats it is counted as one page per 500 words (pageCountBasis: "word-equivalent").

If you set a maximum cost per run, the Actor checks before converting each document. It stops cleanly when the next document wouldn't fit, rather than charging partway through one. Apify's free plan includes monthly usage credit that you can use to try this Actor.

Limitations

OCR is AI-based and slower. It is accurate on clean scans but can misread poor scans or handwriting, and very dense pages may be cut off (the quality report warns you). Expect roughly 10–20 seconds per page (4 pages run in parallel). OCR only runs on pages with no text layer, so text inside images on normal pages (charts, screenshots) is not read.
PDF layout: multi-column PDFs are read in the order the text appears in the file, which is usually but not always reading order. PDF table detection works best for ruled tables. Borderless tables stay as plain text, and charts are occasionally mistaken for tables.
PDF headings are a best guess. They are inferred from font size and bold text, so PDFs that style headings like body text get few or none, and the odd bold line may be promoted to a heading.
HTML clean-up is rule-based. Common navigation, sidebar, cookie and footer blocks are removed, but unusual page templates may keep some boilerplate. Only the page you give is fetched; JavaScript-rendered pages may come out empty.
Folder links: Google Drive, Dropbox and SharePoint / OneDrive for Business folders work; OneDrive personal folders don't (Microsoft requires a sign-in). Google Drive shortcuts to other files are skipped, and Dropbox folders are downloaded whole, so very large Dropbox folders with videos need a subfolder link or a higher maxFolderDownloadMb.
Access: files behind a login work only if you can pass the right requestHeaders. Cloud share links must be shared as "anyone with the link". New-style OneDrive personal links that require a Microsoft sign-in can't be downloaded; upload the file instead (OneDrive for Business / SharePoint links work). For security, addresses on private networks (such as 10.x, 192.168.x, localhost, cloud metadata) are blocked.
Legacy .doc and .ppt are not supported. Save them as .docx or .pptx first.

Use it from an AI agent (MCP)

Add Apify's MCP server to your agent (Claude, Cursor, VS Code and others) with only this Actor as a tool:

{
  "mcpServers": {
    "document-to-markdown": {
      "url": "https://mcp.apify.com?tools=flyingkiwi/document-to-markdown"
    }
  }
}

The agent sees a tool for this Actor. It signs you in to Apify with OAuth on first use, or you can add an "Authorization": "Bearer <APIFY_TOKEN>" header instead. A typical call is just:

{ "url": "https://example.com/report.pdf" }

The tool returns the converted row (Markdown, page and word counts, quality report). The agent can check quality.possibleContentLoss before trusting the text, and retry with "ocr": true if scannedPages is not empty.

From code, one HTTP call returns the Markdown:

curl -X POST "https://api.apify.com/v2/acts/flyingkiwi~document-to-markdown/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' -d '{"url": "https://arxiv.org/pdf/1706.03762"}'

For single-document runs, the plain Markdown is also saved as the run's OUTPUT record (text/markdown), so run-sync (which returns OUTPUT) gives you the Markdown text directly.

Privacy and responsible use

Only convert documents you have the right to use. This Actor downloads only the URLs you give it and does not crawl other pages.
Documents are processed inside your Apify run. Results are stored only in your run's own storage, which follows your Apify data-retention settings. By default nothing is sent to any AI model or third-party service.
When you turn on OCR, images of the scanned pages (and only those pages) are sent through Apify's AI proxy to the model you choose (default: Google Gemini 2.5 Flash via OpenRouter). Don't turn OCR on for documents you aren't allowed to share with that provider.
Request headers you enter are stored as encrypted secret input and sent only to the hosts of your URLs.
The developer of this Actor can't see your inputs or results.

FAQ

Can I use it from an AI agent or via API? Yes. See the MCP section above, or call it like any Apify Actor through the Apify API and client libraries.

How do I upload files?

In Upload files, click to upload and choose your documents. Apify asks which key-value store to put them in: pick an existing store or create a new one (for example my-documents).
In the next field, Key-value store with your uploads, pick that same store.
Click Start.

The second step is how Apify gives this Actor read-only access to that one store; it can't see anything else in your account. If you forget it, the result row tells you which store to pick. If you use the same store every time, you only choose it once per saved task. Links skip all of this: public URLs and Google Drive, Dropbox, OneDrive or SharePoint file or folder links work with no extra steps.

Can I convert files from Google Drive or Dropbox? Yes. Paste the normal share link (shared as "anyone with the link"), for a single file or a whole folder. Google Docs, Sheets and Slides are exported as DOCX, XLSX and PPTX first. For private files, upload them instead.

Can it read scanned PDFs? Yes, with "ocr": true. Only pages without a text layer are OCR'd and charged.

Does it keep images? No. Images are not extracted. Image alt text from HTML/DOCX may appear.

Something didn't convert correctly? Please open an issue in the Issues tab with the file URL (if it's public) and we'll look into it.

Not affiliated with Microsoft. MarkItDown is used under its MIT licence.

Changelog

This Actor's version history is a separate document: https://apify.com/flyingkiwi/document-to-markdown/changelog.md

Actor input Schema

`url` (type: `string`):

One document or folder to convert: a public link, a Google Drive / Google Docs / Dropbox / OneDrive / SharePoint file share link, or a shared FOLDER link (Google Drive, Dropbox, SharePoint / OneDrive for Business, shared as "anyone with the link") to convert every supported file in it. The simplest input for AI agents. Use "Document URLs" or "Upload files" for more.

`urls` (type: `array`):

More documents or folders: public URLs, file share links (Google Drive, Google Docs/Sheets/Slides, Dropbox, OneDrive, SharePoint) or shared folder links (Google Drive, Dropbox, SharePoint / OneDrive for Business). Each supported file in a folder becomes its own result. Supported formats: PDF, DOCX, PPTX, XLSX, XLS, HTML, EPUB, CSV, IPYNB, TXT, MD, JSON, XML.

`files` (type: `array`):

Upload documents from your computer. Apify saves each upload in one of your key-value stores (you choose or create the store in the upload dialog). Then pick that same store in the next field, "Key-value store with your uploads", so the Actor is allowed to read it. Links need no extra step: public URLs and Google Drive, Dropbox, OneDrive or SharePoint file or folder links work on their own. Via the API you can also pass Apify key-value store record URLs (signed URLs work on their own).

`filesStore` (type: `string`):

Only needed if you use "Upload files": pick the key-value store your files were uploaded into. The Actor gets read-only access to that one store and converts just the files you uploaded. If "Upload files" is empty, it converts every document in the store you pick (up to 1,000). Nothing in the store is changed.

`maxFiles` (type: `integer`):

For shared folder links: convert at most this many supported files from each folder (subfolders included). Files past the limit are listed in the run summary. Each converted file is charged as one document, and the run also stops cleanly at your maximum cost per run.

`includeSubfolders` (type: `boolean`):

For shared folder links: also convert files in subfolders (all levels). Each result has a relativePath like "Reports/2024/q1.pdf".

`maxFolderDownloadMb` (type: `integer`):

Dropbox shares a folder as a single ZIP of everything in it (including videos and images), so the run downloads that ZIP and converts the supported files inside. Folders larger than this are refused with a clear message: link a smaller subfolder or raise the limit. Not used for Google Drive or SharePoint, which download only the supported files.

`requestHeaders` (type: `object`):

Extra HTTP headers for downloading your URLs, e.g. {"Authorization": "Bearer ..."} or a Cookie for a private intranet or API. Sent only to the host of each URL you give, never to redirect targets or other sites. Stored encrypted.

`ocr` (type: `boolean`):

Read PDF pages that have no text layer (scans, photos) with a vision AI model through Apify's AI proxy. Only pages without text are sent, and only when this is on. Charged per OCR'd page (see Pricing); the AI model usage itself is billed by Apify to your account at cost (about $0.001 per page with the default model).

`ocrMaxPagesPerDocument` (type: `integer`):

Cap on how many scanned pages are OCR'd in one document. Extra scanned pages are left empty and listed in the quality report.

`ocrModel` (type: `string`):

OpenRouter model ID used for OCR via Apify's AI proxy. Must accept images. The default is fast, cheap and accurate.

`chunkSize` (type: `integer`):

If above 0, also split each document into heading-aware chunks of up to this many characters, ready for embeddings. 0 turns chunking off.

`chunkOverlap` (type: `integer`):

How many characters from the end of one chunk to repeat at the start of the next. Only used when chunking is on.

`includeMarkdown` (type: `boolean`):

Put the full Markdown text in each result. Turn off if you only need chunks or the saved .md file.

`saveMarkdownFiles` (type: `boolean`):

Save each converted document as a Markdown record in the run's key-value store and return its URL.

`pdfTables` (type: `boolean`):

Render tables found in PDFs as Markdown tables (best for tables drawn with lines). Each table's text also stays in the page text, so tables add some duplicate words, and large PDFs convert slower. Turn off for plain text only. Word, PowerPoint, Excel and HTML tables are always kept.

`maxFileSizeMb` (type: `integer`):

Files larger than this are skipped (not charged).

`maxPagesPerDocument` (type: `integer`):

Documents with more pages than this are skipped (not charged). Protects you from unexpectedly large bills. For non-paginated formats one page = 500 words.

`maxConcurrency` (type: `integer`):

How many documents to process at the same time.

`requestTimeoutSecs` (type: `integer`):

Maximum time to download one file. Conversion may take up to 3 times longer for large files.

Actor input object example

{
  "url": "https://arxiv.org/pdf/1706.03762",
  "maxFiles": 500,
  "includeSubfolders": true,
  "maxFolderDownloadMb": 500,
  "ocr": false,
  "ocrMaxPagesPerDocument": 50,
  "ocrModel": "google/gemini-2.5-flash",
  "chunkSize": 0,
  "chunkOverlap": 200,
  "includeMarkdown": true,
  "saveMarkdownFiles": true,
  "pdfTables": true,
  "maxFileSizeMb": 25,
  "maxPagesPerDocument": 300,
  "maxConcurrency": 3,
  "requestTimeoutSecs": 60
}

Actor output Schema

`markdown` (type: `string`):

No description

`results` (type: `string`):

No description

`files` (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

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 = {
    "url": "https://arxiv.org/pdf/1706.03762"
};

// Run the Actor and wait for it to finish
const run = await client.actor("flyingkiwi/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

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 = { "url": "https://arxiv.org/pdf/1706.03762" }

# Run the Actor and wait for it to finish
run = client.actor("flyingkiwi/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

echo '{
  "url": "https://arxiv.org/pdf/1706.03762"
}' |
apify call flyingkiwi/document-to-markdown --silent --output-dataset

MCP server setup

{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,flyingkiwi/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/qA3oC0yssNKFucYa7/builds/MHoroTpNMSTqHUo1y/openapi.json

Document to Markdown (Apify Actor)

호스팅형 MCP 서버

문서

PDF to Markdown & Document Converter: DOCX, PPTX, XLSX, OCR (flyingkiwi/document-to-markdown) Actor

Pricing

What's an Apify Actor?

How to integrate an Actor?

README

PDF to Markdown & Document Converter (DOCX, PPTX, XLSX, OCR)

What does Document to Markdown do?

Why use it?

Supported formats

How to use it

Input examples

Main input options

Output example

Converting a whole folder

Pricing

Limitations

Use it from an AI agent (MCP)

Privacy and responsible use

FAQ

Changelog

Actor input Schema

url (type: string):

urls (type: array):

files (type: array):

filesStore (type: string):

maxFiles (type: integer):

includeSubfolders (type: boolean):

maxFolderDownloadMb (type: integer):

requestHeaders (type: object):

ocr (type: boolean):

ocrMaxPagesPerDocument (type: integer):

ocrModel (type: string):

chunkSize (type: integer):

chunkOverlap (type: integer):

includeMarkdown (type: boolean):

saveMarkdownFiles (type: boolean):

pdfTables (type: boolean):

maxFileSizeMb (type: integer):

maxPagesPerDocument (type: integer):

maxConcurrency (type: integer):

requestTimeoutSecs (type: integer):

Actor input object example

Actor output Schema

markdown (type: string):

results (type: string):

files (type: string):

API

JavaScript example

Python example

CLI example

MCP server setup

OpenAPI specification

PDF to Markdown & Document Converter: DOCX, PPTX, XLSX, OCR (`flyingkiwi/document-to-markdown`) Actor

`url` (type: `string`):

`urls` (type: `array`):

`files` (type: `array`):

`filesStore` (type: `string`):

`maxFiles` (type: `integer`):

`includeSubfolders` (type: `boolean`):

`maxFolderDownloadMb` (type: `integer`):

`requestHeaders` (type: `object`):

`ocr` (type: `boolean`):

`ocrMaxPagesPerDocument` (type: `integer`):

`ocrModel` (type: `string`):

`chunkSize` (type: `integer`):

`chunkOverlap` (type: `integer`):

`includeMarkdown` (type: `boolean`):

`saveMarkdownFiles` (type: `boolean`):

`pdfTables` (type: `boolean`):

`maxFileSizeMb` (type: `integer`):

`maxPagesPerDocument` (type: `integer`):

`maxConcurrency` (type: `integer`):

`requestTimeoutSecs` (type: `integer`):

`markdown` (type: `string`):

`results` (type: `string`):

`files` (type: `string`):