# PDF to Markdown for RAG & LLMs (tables, no API key needed) (`vivid_astronaut/pdf-to-markdown-for-rag`) Actor Convert PDFs to clean structured Markdown for RAG and LLM ingestion. Preserves tables. Flat $0.004/page, no API key required. - **URL**: https://apify.com/vivid\_astronaut/pdf-to-markdown-for-rag.md - **Developed by:** [Fabio Suizu](https://apify.com/vivid_astronaut) (community) - **Categories:** AI, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $3.00 / 1,000 document pages 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/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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. Actors are written with capital "A". ## 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. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## PDF to Markdown for RAG & LLMs — Tables Preserved, $0.004/page, No API Key Needed Turn **any PDF URL** into clean, structured **Markdown** that is ready to feed into RAG pipelines, vector databases, and LLM prompts — with **zero setup**. Paste PDF links. Press **Start**. Get Markdown with real headings, lists, and **actual Markdown tables** instead of collapsed text soup. That's it. **No LlamaParse key. No Reducto contract. No OpenAI account. No monthly subscription.** You pay a flat **$0.004 per page** through Apify — everything else is included. --- ### Why this Actor? Every serious RAG or agent pipeline hits the same wall: PDFs. Naive extractors (pypdf, pdftotext) destroy tables, shuffle multi-column layouts, and drop heading structure — and your retrieval quality dies with them. The dedicated parsing APIs (LlamaParse, Reducto, Unstructured) fix that, but they make you sign up for **another account, another API key, another bill**. This Actor runs on a managed document-parsing backend — the key is built in. | | **This Actor** | LlamaParse | Reducto | DIY (pypdf & friends) | | ---------------------------- | ---------------------------------- | ---------------------------------- | ----------------------------- | ---------------------------- | | Requires your own API key | **No — works out of the box** | Yes (LlamaCloud key + credits) | Yes (sales contact) | — | | Price per page | **$0.004 flat** | $0.003–$0.056 depending on mode | ~5× more | "Free" + your engineering time | | Tables | **Real Markdown tables** | Mode-dependent | Yes | Usually destroyed | | Headings & structure | **Proper `#`/`##` hierarchy** | Yes | Yes | Flat text | | Setup | **None — paste URLs** | Account, credits, SDK | Contract, integration | Code, maintenance | | Billing | **Pay per event — only pages actually converted** | Credit packs | Enterprise contract | — | A 20-page contract costs **$0.08**. A 300-page annual report costs **$1.20**. Failed documents are never charged. ### What it does 1. **Downloads each PDF** from any direct URL — public links, presigned S3/GCS URLs, or files stored in an Apify key-value store. Files are validated as real PDFs before processing (an HTML viewer page instead of a raw file produces a clear error, not garbage output). 2. **Parses the document with layout awareness**: reading order is reconstructed (multi-column pages come out in the right sequence), headings become `#`/`##`/`###`, lists stay lists, and tables are emitted as GitHub-flavored Markdown tables — the single biggest quality lever for RAG over business documents. 3. **Outputs Markdown twice**: inline in the dataset item (for API consumers and agents) and as a downloadable `.md` file in the run's key-value store (for humans and downstream jobs). 4. **Keeps going on failure**: a dead link or corrupt file produces an `{ url, error }` item; the rest of the batch is processed and only successful pages are charged. ### Input ```json { "sources": [ "https://slicedinvoices.com/pdf/wordpress-pdf-invoice-plugin-sample.pdf", "https://example.com/reports/annual-report-2025.pdf" ], "maxPages": 500 } ```` | Field | Type | Default | Description | | ---------- | ------- | ------------ | ------------------------------------------------------------------------------ | | `sources` | array | *(required)* | URLs of PDF files: direct links or Apify key-value store record URLs | | `maxPages` | integer | `500` | Safety cap per document; larger documents produce an error item and are never charged | ### Output One dataset item per source. Here is the result for the sample invoice above: ```json { "url": "https://slicedinvoices.com/pdf/wordpress-pdf-invoice-plugin-sample.pdf", "filename": "wordpress-pdf-invoice-plugin-sample.pdf", "pages": 1, "char_count": 731, "charged_pages": 1, "markdown": "# Invoice\n\n**From:** Sliced Invoices...", "files": { "md": "https://api.apify.com/v2/key-value-stores//records/001-slicedinvoices.com-pdf-wordpress-pdf-invoice-plugin.md" } } ``` And the Markdown itself — note the tables survive as tables: ```markdown ## Invoice **From:** Sliced Invoices — Suite 5A-1204, 123 Somewhere Street, Your City AZ 12345 **To:** Test Business — 123 Somewhere St, Melbourne VIC 3000 | Invoice Number | Order Number | Invoice Date | Due Date | Total Due | | -------------- | ------------ | ---------------- | ---------------- | --------- | | INV-3337 | 12345 | January 25, 2016 | January 31, 2016 | $93.50 | | Service | Description | Hrs/Qty | Rate/Price | Adjust | Sub Total | | ---------- | ------------------------------------ | ------- | ---------- | ------ | --------- | | Web Design | New website design and development | 1.00 | $85.00 | 0.00% | $85.00 | | Sub Total | $85.00 | | --------- | ---------- | | Tax | $8.50 | | **Total** | **$93.50** | ``` That is exactly what you want in a vector store: an LLM can answer "what is the total due and when?" from this chunk directly, no layout guessing. If a source fails (dead link, not a PDF, over the page cap), the run **keeps going** and the failed source produces: ```json { "url": "https://example.com/broken-link.pdf", "error": "Could not download the file: HTTP 404" } ``` ### Pricing **$0.004 per converted page**, minimum 1 page per document. Billed via Apify's pay-per-event — no subscription, no credit packs, no compute-unit math. | Workload | Cost | | --------------------------------------- | --------- | | 1-page invoice | $0.004 | | 20-page contract | $0.08 | | 300-page annual report | $1.20 | | 1,000 × 2-page invoices | $8.00 | | Same annual report on LlamaParse Premium (~$0.045/page) + a LlamaCloud account | $13.50 and two invoices | Documents that fail to download or convert are **never charged**. Documents over your `maxPages` cap are **never charged**. ### Use it via API Run the Actor from any language using the [Apify API](https://docs.apify.com/api/v2): ```bash curl -X POST "https://api.apify.com/v2/acts/~pdf-to-markdown-for-rag/run-sync-get-dataset-items?token=$APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "sources": ["https://slicedinvoices.com/pdf/wordpress-pdf-invoice-plugin-sample.pdf"] }' ``` JavaScript: ```js import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: process.env.APIFY_TOKEN }); const run = await client.actor('/pdf-to-markdown-for-rag').call({ sources: ['https://slicedinvoices.com/pdf/wordpress-pdf-invoice-plugin-sample.pdf'], }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items[0].markdown); ``` Python (drop-in for a RAG ingestion job): ```python from apify_client import ApifyClient client = ApifyClient(os.environ["APIFY_TOKEN"]) run = client.actor("/pdf-to-markdown-for-rag").call( run_input={"sources": ["https://slicedinvoices.com/pdf/wordpress-pdf-invoice-plugin-sample.pdf"]} ) for item in client.dataset(run["defaultDatasetId"]).list_items().items: chunks = split_markdown(item["markdown"]) # your chunker vector_store.add(chunks, metadata={"source": item["url"]}) ``` ### Use it from AI agents (MCP) This Actor works out of the box with the [Apify MCP server](https://mcp.apify.com), so agents built on Claude, ChatGPT, Cursor, or any MCP-compatible framework can call it as a tool: ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com/sse?actors=/pdf-to-markdown-for-rag" } } } ``` Your agent can turn any PDF a user shares into LLM-ready Markdown with **no API key juggling inside the agent** — this Actor needs none, and pay-per-event billing means you are only ever charged for pages actually converted. ### FAQ **Do I need a LlamaParse / Reducto / OpenAI API key?** No. That is the point of this Actor. Parsing runs on a managed backend whose credentials are bundled with the Actor. You only need your Apify account. **Why Markdown and not plain text or JSON?** Markdown is the lingua franca of LLM ingestion: heading hierarchy gives your chunker natural split points, tables stay machine-readable, and every major framework (LangChain, LlamaIndex, Haystack) has first-class Markdown loaders. Plain text loses structure; per-block JSON makes you rebuild it. **How are tables handled?** Tables are detected from the page layout and emitted as GitHub-flavored Markdown tables (pipes and header rows), not as space-aligned text. Merged or deeply nested table cells are flattened on a best-effort basis. **Does it work on scanned PDFs?** Digital (text-based) PDFs give the best results. Scanned pages are processed through the backend's visual document understanding, so typical scanned invoices and contracts work; very low-quality scans may reduce accuracy. **Which languages are supported?** The parser is language-agnostic for Latin-script languages and handles the major non-Latin scripts (CJK, Cyrillic, Arabic) as long as the PDF carries proper text or a legible scan. **How long does a conversion take?** Simple digital PDFs process in seconds. Heavy, scan-based, or very large documents can take up to ~20 seconds per page; each document has a generous 20-minute processing budget. **What are the size limits?** Up to 1 GB per file download and `maxPages` pages per document (default 500, configurable up to 10,000). Anything over a limit produces an error item and is never charged. **What happens when one URL in my batch is broken?** The run continues. The broken URL produces a `{ url, error }` item in the dataset; all other documents are processed and only successful pages are charged. **Where is my Markdown file?** Twice in the run: inline in the dataset item (`markdown` field) and as a downloadable `.md` file in the run's key-value store — each item links to it under `files.md`. **Can I convert DOCX, PPTX, or HTML?** This Actor is tuned for PDF. For other formats, print/export them to PDF first (most converters do this losslessly) and pass the resulting URL. **Is my document stored?** Documents are processed transiently and deleted from the worker after conversion. The resulting Markdown lives in your Apify dataset/key-value store, under your control. ### Related use cases - Build RAG knowledge bases from contracts, reports, manuals, and research papers - Feed clean document context to AI agents (Claude, ChatGPT, custom LLM apps) via MCP - Extract invoice and financial-statement tables into readable, diffable Markdown - Preprocess PDF corpora for fine-tuning or embedding pipelines - Archive PDFs as searchable, greppable, version-controllable Markdown # Actor input Schema ## `sources` (type: `array`): URLs of PDF files to convert: direct links (.pdf) or files stored in an Apify key-value store. ## `maxPages` (type: `integer`): Safety limit. Documents with more pages produce an error item instead of a conversion (and are never charged). ## Actor input object example ```json { "sources": [ "https://slicedinvoices.com/pdf/wordpress-pdf-invoice-plugin-sample.pdf" ], "maxPages": 500 } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "sources": [ "https://slicedinvoices.com/pdf/wordpress-pdf-invoice-plugin-sample.pdf" ] }; // Run the Actor and wait for it to finish const run = await client.actor("vivid_astronaut/pdf-to-markdown-for-rag").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "sources": ["https://slicedinvoices.com/pdf/wordpress-pdf-invoice-plugin-sample.pdf"] } # Run the Actor and wait for it to finish run = client.actor("vivid_astronaut/pdf-to-markdown-for-rag").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "sources": [ "https://slicedinvoices.com/pdf/wordpress-pdf-invoice-plugin-sample.pdf" ] }' | apify call vivid_astronaut/pdf-to-markdown-for-rag --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=vivid_astronaut/pdf-to-markdown-for-rag", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "PDF to Markdown for RAG & LLMs (tables, no API key needed)", "description": "Convert PDFs to clean structured Markdown for RAG and LLM ingestion. Preserves tables. Flat $0.004/page, no API key required.", "version": "1.0", "x-build-id": "85lZNkhdBc7uJPAeW" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/vivid_astronaut~pdf-to-markdown-for-rag/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-vivid_astronaut-pdf-to-markdown-for-rag", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/vivid_astronaut~pdf-to-markdown-for-rag/runs": { "post": { "operationId": "runs-sync-vivid_astronaut-pdf-to-markdown-for-rag", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/vivid_astronaut~pdf-to-markdown-for-rag/run-sync": { "post": { "operationId": "run-sync-vivid_astronaut-pdf-to-markdown-for-rag", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "sources" ], "properties": { "sources": { "title": "PDF sources", "type": "array", "description": "URLs of PDF files to convert: direct links (.pdf) or files stored in an Apify key-value store.", "items": { "type": "string" } }, "maxPages": { "title": "Max pages per document", "minimum": 1, "maximum": 10000, "type": "integer", "description": "Safety limit. Documents with more pages produce an error item instead of a conversion (and are never charged).", "default": 500 } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```