# PDF Tables to JSON with Cell Coordinates + RAG Chunks (OCR) (`landoz/pdf-to-json-tables`) Actor PDF to JSON: every table as rows of cells with page number and bounding box, RAG-ready text chunks with page references, plus page text and Markdown. PDF table extraction and PDF parser for AI agents and data pipelines, optional OCR for scanned PDFs, pay per page. - **URL**: https://apify.com/landoz/pdf-to-json-tables.md - **Developed by:** [Landon Brewington](https://apify.com/landoz) (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 $3.00 / 1,000 pdf page processeds 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](#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 Tables to JSON with Cell Coordinates + RAG Chunks (OCR) Give this Actor PDF URLs and get structured JSON back. Two things set it apart from the usual PDF text extractor: 1. **Tables as cells with coordinates.** Every table comes back as `rows` (an array of rows, each row an array of cell strings, already split), with its `page` number, a `bbox` `[x0, top, x1, bottom]` in PDF points, a detected `header`, a GitHub Markdown rendering, and, on request, a `bbox` for every single cell. You can link any value back to the exact spot on the page. 2. **RAG-ready chunks with page references.** Page text is split into sentence-aligned chunks of a size you choose, each carrying `page`, `chunkIndex`, `charStart`, `charEnd` and a `citation` object, so citations in a retrieval pipeline point at a page and a character range, not just a file. The chunks use the same schema as the sibling Actor [transcribe-to-json-chunks](https://apify.com/landoz/transcribe-to-json-chunks), which returns recordings as chunks with time citations, so one pipeline can ingest PDFs and audio or video the same way. On top of that you get each page's plain text, a Markdown version (headings by font size, tables in place), PDF metadata, and optional OCR for scanned pages. It is a PDF to JSON converter, a PDF table extraction tool, a PDF parser, a PDF to Markdown converter and a RAG chunker in one call, priced per page. ### What it does - Downloads each PDF from the URL you give (up to 100 per run, 50 MB each by default), checks that it really is a PDF, and parses it page by page. Nothing is stored after the run: the file is deleted as soon as it is parsed. - **Tables:** ruled tables are found by their lines; when ruled columns have no row lines the cells are re-read by text rows; tables without any lines are found by text alignment with strict quality filters (at least 3 rows, 2 columns, half the cells filled, some numeric content) so paragraphs do not come back as fake tables. Overlapping detections are merged, tables under 2 rows or 2 columns are dropped. Each table has `tableIndex`, `page`, `bbox`, `rowCount`, `columnCount`, `header` (array or null), `rows`, `markdown`, `strategy`, and with `includeCellBoxes` a `cells` array of `{row, col, text, bbox}`. - **Text:** reading-order text per page with line breaks. Pages whose generator wrote no space glyphs (common with TeX and some report tools) still come back with proper word spacing. - **Markdown:** lines whose font is 20 percent above the page's body text become `##` headings, wrapped lines are joined into paragraphs, tables are rendered as Markdown tables where they appear. - **Chunks:** `chunkSize` characters (default 1200, about 300 tokens) with `chunkOverlap` (default 150), cut at sentence ends when possible. Offsets are into that page's `text`. Each chunk carries `citation: {"type": "page", "page": 2, "label": "p. 2"}` (see Family below). - **OCR:** `off` (default), `auto` (only pages with fewer than 20 characters of text layer) or `always`. Pages are rendered at 200 dpi and read with Tesseract. OCR pages return text, Markdown paragraphs and chunks; with `includeWordBoxes` also word boxes with confidence. About 2 to 3 seconds per page. - **Two output shapes:** `pages` (one dataset item per page, the default, ideal for RAG) or `documents` (one item per PDF with `metadata`, all text joined by form feeds, and every table and chunk tagged with its page). - A PDF that cannot be fetched or read never fails the run: it produces one item with `error` and `errorType` (`http_403`, `http_404`, `not_pdf`, `too_large`, `timeout`, `encrypted`, ...) and is not charged. The other PDFs still return data. ### Who it is for - **AI agents and RAG pipelines** that need page-cited chunks and real tables instead of a wall of text. Call it through the Apify MCP server (see below) and index the `chunks` array as is. - **Data teams** turning recurring PDF reports into rows: statistical releases, price lists, schedules, invoices with a text layer. - **Finance and research analysts** pulling tables out of filings, central bank releases and research reports, with coordinates to verify every number against the page. - **Compliance and legal teams** that must quote a page and position, not just a document. - Anyone who needs **PDF to Markdown** or **OCR PDF to text** for a handful of pages without installing anything. ### Quick start 1. Open the Actor in Apify Console and press Start. The default input parses a public Federal Reserve statistical release (12 pages, several tables) in a few seconds. 2. Replace the URL with your own PDF link. Use `pages` like `"1-5,8"` to parse only what you need. 3. For scanned PDFs set `ocr` to `auto` (mixed documents) or `always` (fully scanned). 4. For one JSON object per file set `outputMode` to `documents`. 5. Read results from the default dataset (JSON, CSV or Excel) or the API: `https://api.apify.com/v2/datasets//items`. The `SUMMARY` record in the key-value store lists every file's status, pages processed and charged, OCR pages and errors. ### Input example ```json { "pdfUrls": ["https://www.federalreserve.gov/releases/h41/current/h41.pdf"], "pages": "1-3", "outputMode": "pages", "extractTables": true, "markdown": true, "chunkSize": 1200, "chunkOverlap": 150, "ocr": "off", "includeCellBoxes": false } ``` All fields are optional. A run with no input parses the Federal Reserve release above. | Field | Type | Default | Meaning | | ------------------------------------------ | ----------------------- | -------------- | ------------------------------------------------ | | `pdfUrls` | array of strings | one sample PDF | Public http(s) links to PDF files, up to 100 | | `pdfUrl` | string | empty | Shortcut for a single URL, merged into `pdfUrls` | | `pages` | string | all | 1-based pages like `"1-5,8"` or `"3-"` | | `maxPagesPerPdf` | integer 1 to 1000 | 50 | Cap on pages processed and charged per file | | `outputMode` | `pages` or `documents` | `pages` | One item per page, or one per PDF | | `extractTables`, `extractText`, `markdown` | booleans | true | Turn parts of the output off | | `chunkSize` | integer | 1200 | Chunk size in characters, 0 disables chunks | | `chunkOverlap` | integer | 150 | Characters shared by consecutive chunks | | `ocr` | `off`, `auto`, `always` | `off` | When to run OCR | | `ocrLanguage` | string | `eng` | Tesseract language, only English is installed | | `maxFileSizeMb` | integer 1 to 200 | 50 | Larger files are skipped with an error item | | `includeWordBoxes` | boolean | false | Add every word with its box to each page | | `includeCellBoxes` | boolean | false | Add a box for every table cell | ### Output example One page item from the default run (page 2 of the Federal Reserve H.4.1 release; `text`, `markdown`, `rows` and `chunks` are shortened here): ```json { "sourceUrl": "https://www.federalreserve.gov/releases/h41/current/h41.pdf", "documentId": "6cb2cd9838d643a55fd6591794268e74e7b0224d", "fileName": "h41.pdf", "page": 2, "pageCount": 12, "width": 612, "height": 792, "text": "FEDERAL RESERVE statistical release\nH.4.1\nFactors Affecting Reserve Balances of Depository Institutions and\nCondition Statement of Federal Reserve Banks\nOctober 22, 2026\n1. Factors Affecting Reserve Balances of Depository Institutions\nMillions of dollars\n...", "markdown": "## FEDERAL RESERVE statistical release\n\nH.4.1\n\n## Factors Affecting Reserve Balances of Depository Institutions and\n\n...\n\n| Averages of daily figures | | |\n| --- | --- | --- |\n| Oct 21, 2026 | Oct 14, 2026 | Oct 22, 2025 |\n| 6,706,861 | - 789 | + 161,908 |\n...", "tables": [ { "tableIndex": 0, "page": 2, "bbox": [251.75, 173.27, 503.75, 519.23], "rowCount": 33, "columnCount": 3, "header": ["Averages of daily figures", "", ""], "rows": [ ["Averages of daily figures", "", ""], ["", "Change from week ended", ""], ["Week ended", "", ""], ["Oct 21, 2026", "Oct 14, 2026", "Oct 22, 2025"], ["6,706,861", "- 789", "+ 161,908"], ["6,470,860", "+ 492", "+ 187,540"] ], "markdown": "| Averages of daily figures | | |\n| --- | --- | --- |\n...", "strategy": "lines+text" } ], "chunks": [ { "chunkIndex": 0, "page": 2, "charStart": 0, "charEnd": 608, "text": "FEDERAL RESERVE statistical release\nH.4.1\n...", "citation": { "type": "page", "page": 2, "label": "p. 2" } }, { "chunkIndex": 1, "page": 2, "charStart": 460, "charEnd": 1659, "text": "...", "citation": { "type": "page", "page": 2, "label": "p. 2" } }, { "chunkIndex": 2, "page": 2, "charStart": 1509, "charEnd": 2103, "text": "...", "citation": { "type": "page", "page": 2, "label": "p. 2" } } ], "ocrUsed": false, "charCount": 2103, "warnings": [], "extractedAt": "2026-10-23T05:39:57.921Z" } ``` With `includeCellBoxes: true` each table also has `"cells": [{"row": 4, "col": 0, "text": "6,706,861", "bbox": [251.75, 208.93, 337.25, 217.95]}, ...]`. Coordinates are PDF points (1/72 inch) with the origin at the top-left corner of the page; `width` and `height` give the page size in the same unit, so dividing by them yields relative positions for any viewer. In `documents` mode the item has `pageCount`, `pagesProcessed`, `pages`, `metadata` (`title`, `author`, `creator`, `producer`, `creationDate`), `text` (pages joined with `\f`), `markdown`, `tables` (all pages, each with `page`), `chunks` (all pages, each with `page`), `ocrPagesUsed`, `charCount`, `warnings` and `extractedAt`. ### Family: the same chunks for PDFs and recordings This Actor has a sibling, [transcribe-to-json-chunks](https://apify.com/landoz/transcribe-to-json-chunks), which turns audio and video (MP3, WAV, M4A, MP4, MOV, WebM and more) into the exact same chunk schema with time citations instead of page citations. Both emit: ```json { "chunkIndex": 0, "text": "...", "charStart": 0, "charEnd": 1187, "citation": { "type": "page", "page": 3, "label": "p. 3" } } { "chunkIndex": 0, "text": "...", "charStart": 0, "charEnd": 1187, "citation": { "type": "time", "startMs": 723000, "endMs": 768000, "label": "00:12:03-00:12:48" } } ``` So one ingestion pipeline can index `chunks[].text` with `citation.label` as the display reference, whether the source was a 40-page report or a 40-minute meeting recording. The chunker is the same code in both Actors (sentence-aligned, character-sized, with overlap), so chunk boundaries behave the same way too. ### Pricing in plain words Pay per page, nothing else: **$0.003 per page processed** (the `page-processed` event), plus **$0.01 per page only when OCR actually ran on it** (the `ocr-page` event), plus Apify's standard tiny Actor start fee. A 30-page report costs 9 cents; fully OCR'd it costs 39 cents. Both output modes charge per processed page. Failed downloads and unreadable PDFs are never charged. You set the maximum you are willing to spend per run; when the limit is reached the Actor stops parsing and still finishes successfully, and the `SUMMARY` record says so. Platform compute is included in the price. ### Limits - **File size:** 50 MB per PDF by default (`maxFileSizeMb`, up to 200). Up to 100 URLs per run. - **Pages:** 50 per PDF by default (`maxPagesPerPdf`, up to 1000). `pageCount` always shows the true total. - **Text-layer PDFs only unless you turn OCR on.** A scanned PDF returns empty text with `ocr: "off"`; use `auto` or `always`. OCR takes about 2 to 3 seconds per page and is English only (`eng`) in this build. - **Encrypted or password-protected PDFs** are not supported and return an `encrypted` error item. - **Table detection is heuristic.** Ruled tables are reliable. Tables drawn only with whitespace are found when they look like data (mostly numbers, dense); text-only tables without lines may be missed, and caption lines directly above an unruled table can be absorbed as a first row. Where a ruled table has sub-columns without lines, those values stay together in one cell. Check `strategy` and `bbox` when quality matters. - **Reading order** follows the PDF's own layout; multi-column articles are read left to right by line, as most parsers do. - **URLs must be public.** Pages behind a login (HTTP 401) or a bot wall (HTTP 403) return an error item; upload such files to storage you control (for example an Apify key-value store) and pass that URL. - Runs are stateless. PDFs are fetched from the URLs you provide, parsed in memory and on the run's disk, and deleted when the run ends. Only the JSON you see in the dataset is kept. ### Use it from an AI agent (Apify MCP server) Connect your agent to `https://mcp.apify.com` (see the Apify MCP docs for Claude, Cursor, VS Code and others). Then: 1. Search for the tool: `search-actors` with the query "pdf to json" or "pdf table extraction". 2. Read the schema: `fetch-actor-details` for this Actor returns the input fields above and the dataset schema. 3. Call it: `call-actor` with `{"pdfUrls": ["https://example.com/report.pdf"]}`, or `{"pdfUrls": ["..."], "pages": "1-10", "outputMode": "documents"}` for one object per file, or `{"pdfUrls": ["..."], "ocr": "auto"}` when some pages may be scanned. 4. Read results with `get-dataset-items`. Index `chunks[].text` with `page`, `charStart` and `charEnd` as metadata; feed `tables[].rows` straight into a dataframe. The Actor runs with limited permissions and charges only pay-per-event events, so it works with Apify's agentic payments. ### Open-source credits and licenses Everything inside is permissively licensed. No copyleft components are used or bundled. | Component | Role | License | | ------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------- | -------------------------- | | [pdfplumber](https://github.com/jsvine/pdfplumber) | Text, words, characters and table detection | MIT | | [pdfminer.six](https://github.com/pdfminer/pdfminer.six) | PDF parsing engine under pdfplumber | MIT | | [pypdfium2](https://github.com/pypdfium2-team/pypdfium2) (PDFium) | Page rendering for OCR | BSD-3-Clause or Apache-2.0 | | [Pillow](https://github.com/python-pillow/Pillow) | Image handling for OCR | MIT-CMU (HPND) | | [pytesseract](https://github.com/madmaze/pytesseract) | Python bridge to Tesseract | Apache-2.0 | | [Tesseract OCR](https://github.com/tesseract-ocr/tesseract) with the `eng` model | OCR engine | Apache-2.0 | | [Apify SDK for JavaScript](https://github.com/apify/apify-sdk-js), [got-scraping](https://github.com/apify/got-scraping) | Actor runtime and downloads | Apache-2.0 / MIT | | Base image `apify/actor-node:22` (Node.js on Alpine Linux) | Runtime | MIT / various permissive | Python dependencies pulled in transitively (cffi, pycparser, cryptography, charset-normalizer, packaging) are MIT, BSD or Apache licensed. The Actor's own code is Apache-2.0. ### FAQ **Does it work on scanned PDFs?** Yes, set `ocr` to `auto` (mixed documents) or `always` (fully scanned). OCR pages cost $0.01 extra each. Only English OCR is installed today. **Why did a table come back with the row labels missing?** When a PDF draws ruled boxes around the numbers but prints the labels outside the box, the label column is not part of the ruled table. The labels are still in `text` and `markdown`, and the table's `bbox` tells you where it sits on the page. **Can I get the position of every cell?** Yes, set `includeCellBoxes: true`. Each table then carries `cells: [{row, col, text, bbox}]`. **One item per page or one per document?** `outputMode: "pages"` (default) gives one dataset item per page, which is the natural unit for RAG. `outputMode: "documents"` gives one item per PDF with every table and chunk tagged with its page. **Are my PDFs stored?** No. Each file is downloaded from the URL you give, parsed, and deleted when the run ends. Results live in your own dataset. **What does it cost?** $0.003 per page processed, plus $0.01 per page only when OCR runs. A 30-page report with a text layer costs 9 cents. **Where do recordings fit?** The sibling Actor [transcribe-to-json-chunks](https://apify.com/landoz/transcribe-to-json-chunks) returns the same chunk schema with time citations. Working pipelines for both are in the [rag-ingestion-examples](https://github.com/landoCommandoz/rag-ingestion-examples) repository. ### Support Open an issue on the Actor's Issues tab in Apify Console. Include the run id, the PDF URL (if you can share it) and the input you used. # Changelog This Actor's version history is a separate document: https://apify.com/landoz/pdf-to-json-tables/changelog.md # Actor input Schema ## `pdfUrls` (type: `array`): Public http(s) links to the PDF files to convert, one per line. Each must point at the PDF itself (not an HTML viewer page). Up to 100 URLs per run; files are fetched once, parsed and deleted when the run ends. ## `pdfUrl` (type: `string`): Convenience field for agents that pass one URL: it is merged into pdfUrls. ## `pages` (type: `string`): Which pages to process, 1-based, like "1-5,8" or "3-" (3 to the end). Empty means all pages up to maxPagesPerPdf. Each processed page is one page-processed event. ## `maxPagesPerPdf` (type: `integer`): Safety cap on pages processed (and charged) per file. Default 50, maximum 1000. Pages beyond the cap are skipped; pageCount in the output still shows the real total. ## `outputMode` (type: `string`): pages: one dataset item per page (best for RAG and for streaming long reports). documents: one item per PDF with all text joined by form feeds, every table and chunk carrying its page number, plus PDF metadata (title, author, creator, producer, creationDate). Both charge per processed page. ## `extractTables` (type: `boolean`): Detect tables and return them as rows of cells with header, row and column counts, a bounding box \[x0, top, x1, bottom] in PDF points and a GitHub Markdown rendering. Ruled tables are found by their lines; tables without lines are found by text alignment with quality filters. ## `extractText` (type: `boolean`): Return the plain text of each page (reading order, line breaks kept) and build chunks from it. Turn off if you only need tables. ## `markdown` (type: `boolean`): Also return each page as Markdown: headings detected from font size (20 percent above the page's body text), paragraphs joined, tables rendered as Markdown tables in place. ## `chunkSize` (type: `integer`): Target size of RAG chunks in characters. Chunks end at sentence boundaries when possible and each carries page, chunkIndex, charStart and charEnd (offsets into that page's text) plus a citation object, the same chunk schema as the transcribe-to-json-chunks Actor. 0 disables chunking. Default 1200 (about 300 tokens). ## `chunkOverlap` (type: `integer`): How many characters consecutive chunks share, so sentences cut at a boundary appear whole in one of them. Capped at half the chunk size. Default 150. ## `ocr` (type: `string`): off: text layer only, fastest and cheapest (default). auto: OCR only pages whose text layer has fewer than 20 characters (scanned pages inside otherwise normal PDFs). always: OCR every page, for fully scanned documents. OCR renders the page at 200 dpi and runs Tesseract; each OCR page adds one ocr-page event and takes a few seconds. ## `ocrLanguage` (type: `string`): Tesseract language code for OCR. Only "eng" (English) is installed in this build; other codes return an OCR warning on each page. Default eng. ## `maxFileSizeMb` (type: `integer`): PDFs larger than this are skipped with an error item instead of being downloaded. Default 50, maximum 200. ## `includeWordBoxes` (type: `boolean`): Add wordBoxes to every page: each word with x0, top, x1, bottom in PDF points (and OCR confidence for OCR pages). Useful for highlighting and layout work; makes items several times larger. ## `includeCellBoxes` (type: `boolean`): Add cells to every table: one entry per cell with row, col, text and its own bbox. Tables already carry a table-level bbox; turn this on when you need per-cell coordinates (for example to link a value back to its spot on the page). ## Actor input object example ```json { "pdfUrls": [ "https://www.federalreserve.gov/releases/h41/current/h41.pdf" ], "maxPagesPerPdf": 50, "outputMode": "pages", "extractTables": true, "extractText": true, "markdown": true, "chunkSize": 1200, "chunkOverlap": 150, "ocr": "off", "ocrLanguage": "eng", "maxFileSizeMb": 50, "includeWordBoxes": false, "includeCellBoxes": false } ``` # Actor output Schema ## `pages` (type: `string`): Every processed page (or document) with text, markdown, tables and chunks, plus one error row per PDF that failed. ## `summary` (type: `string`): Per-file status, pages processed and charged, OCR pages, table counts and errors. # 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 = { "pdfUrls": [ "https://www.federalreserve.gov/releases/h41/current/h41.pdf" ] }; // Run the Actor and wait for it to finish const run = await client.actor("landoz/pdf-to-json-tables").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 = { "pdfUrls": ["https://www.federalreserve.gov/releases/h41/current/h41.pdf"] } # Run the Actor and wait for it to finish run = client.actor("landoz/pdf-to-json-tables").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 '{ "pdfUrls": [ "https://www.federalreserve.gov/releases/h41/current/h41.pdf" ] }' | apify call landoz/pdf-to-json-tables --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,landoz/pdf-to-json-tables" } } } ``` 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 ` 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/7Go3g8sZlL6pqqv08/builds/teTK0zv5Ta8PCps88/openapi.json