PDF Text Extractor: Text, Pages & Tables
The PDF Text Extractor downloads each PDF URL and returns one row per document with the full text, per-page text, PDF metadata including title, author, creator and ISO dates, pageCount and pagesExtracted, an optional tables array, and a status of ok, scanned, empty or error. Scanned image-only documents are flagged rather than silently returned empty. Documents cost $2.00 per 1,000, and scanned or failed rows are free. Run it from Apify Console or the API.
from $0.002 per document with extracted text, $2.00 per 1,000, down to $0.0015 on higher Apify plans · Updated Nov 2026, version 0.1.3
Key facts
- Price
- from $0.002 per document with extracted text, $2.00 per 1,000, down to $0.0015 on higher Apify plans
- Pricing model
- Pay per event
- Output
- JSON, CSV, Excel, XML, RSS via Apify datasets
- Access
- Apify Console, REST API, Python and JS clients, MCP tool pdf_text
- Version
- Updated Nov 2026, version 0.1.3
- Actor
subimpact/pdf-text-extractor
Who it is for
- RAG teams turning reports and filings into clean text
- Finance and legal analysts pulling figures from recurring PDFs
- Document intake teams sorting digital PDFs from scans before OCR
- Researchers extracting text from public papers and standards
Use cases
Build a text corpus from PDF links
List PDF URLs in urls and read text from each row, with whitespace normalised and capped at 1,000,000 characters. truncated tells you when a document hit that cap, and pagesExtracted against pageCount shows how much was read. That gives a clean corpus with the source url, sizeBytes and title attached to every document.
Cite by page number
With includePageTexts on, pageTexts holds one string per extracted page, so a quote can be attributed to page 4 without re-parsing the file. maxPages caps how many pages are read per document while pageCount still reports the true total. Turn includePageTexts off when you only need the joined text and a smaller dataset.
Sort scans from digital PDFs
isScanned is true when a document averages fewer than 20 characters per page, which is how an image-only scan looks. Those rows arrive with status scanned or empty and are not charged. Use that flag to route only true scans into an OCR step, instead of paying OCR for documents that already carry a text layer.
Pull a table out of a recurring report
Set includeTables true and each table comes back as an object with the page number and a rows array of cells. That suits statements, invoices and regulatory tables where layout matters. Table detection is the slowest part of a run, so leave it off for prose documents and enable it only for the reports you actually parse.
Keep document metadata with the text
Each row carries the PDF's own title, author, subject, creator, producer and created and modified dates normalised to ISO 8601. For a filings archive that is enough to sort by publication date or authoring tool, and for a corpus it gives a provenance record alongside sizeBytes and finalUrl after redirects.
Output fields
| Field | Type | Description |
|---|---|---|
url | string | PDF URL as supplied in the input |
finalUrl | string/null | URL after following redirects (null for error rows) |
fileName | string/null | Last path segment of finalUrl |
sizeBytes | integer/null | Bytes downloaded |
pageCount | integer/null | Total pages in the PDF |
pagesExtracted | integer/null | Pages actually read (capped by maxPages) |
title | string/null | PDF metadata title |
author | string/null | PDF metadata author |
subject | string/null | PDF metadata subject |
creator | string/null | PDF metadata creator (authoring application) |
producer | string/null | PDF metadata producer (PDF engine) |
createdAt | string/null | PDF creation date, ISO 8601 UTC |
Show all 22 fields
| Field | Type | Description |
|---|---|---|
modifiedAt | string/null | PDF modification date, ISO 8601 UTC |
text | string/null | Full extracted text with normalised whitespace, capped at 1,000,000 characters |
truncated | boolean | True when text was cut at the 1,000,000 character cap |
pageTexts | array/null | One normalised text string per extracted page (empty string for image-only pages); null when includePageTexts=false |
tables | array/null | Extracted tables as [{page, rows: [[cell, ...], ...]}]; null when includeTables=false |
isScanned | boolean/null | True when the document averages fewer than 20 characters per page (image-only, no OCR in v1); null for error rows |
language | string/null | Coarse language guess from the extracted text (ISO 639-1), null when unsure |
scrapedAt | string | ISO 8601 UTC timestamp of the extraction |
status | string | ok (text found) | scanned (image-only, too little text) | empty (no text at all) | error (could not fetch or parse) |
error | string/null | Why the document was not extracted (error rows only) |
Input
| Field | Type | Required | Description | Default |
|---|---|---|---|---|
urls | array | No | One entry per PDF. A plain URL string or an object with a "url" field both work. Redirects are followed and the resolved URL is reported as finalUrl. | [{"url":"https://www.irs.gov/pub/irs-pdf/fw9.pdf"},{"url":"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-145.pdf"}] |
maxPages | integer | No | Extract at most this many pages from each PDF (default 200). pageCount still reports the real page count; pagesExtracted reports how many were read, and text/pageTexts/tables cover only those pages. Lower it for very large reports to cut... | 200 |
includeTables | boolean | No | Also extract tables with pdfplumber. Each table is returned as {"page": n, "rows": [[cell, ...], ...]}. Off by default because table detection is the slowest part of a run. | false |
includePageTexts | boolean | No | Include pageTexts: one normalised text string per extracted page (empty string for image-only pages). Turn off for a smaller dataset when you only need the full text. | true |
maxDocuments | integer | No | Hard cap on document rows delivered in one run, counting every delivered row (including scanned, empty and error rows). The default of 100 keeps a run well under a dollar; at $0.002 per extracted document, 100 documents cost at most $0.2... | 100 |
maxFileSizeMb | integer | No | Skip (and report as an error row) any PDF larger than this. The download is aborted as soon as it crosses the limit, so oversized files do not fill memory. | 50 |
proxyConfiguration | object | No | Optional. Most PDF hosts serve plain HTTP fine from Apify's datacenter IPs; enable Apify Proxy (or your own proxy URLs) if a publisher blocks the run. Proxy usage is billed by Apify as platform usage. | {"useApifyProxy":false} |
Example input
{
"urls": [
{
"url": "https://www.irs.gov/pub/irs-pdf/fw9.pdf"
},
{
"url": "https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-145.pdf"
},
{
"url": "https://arxiv.org/pdf/1706.03762"
}
]
}Pricing
| Event | What it means | Price | Lowest tier |
|---|---|---|---|
document-extracted | One PDF document delivered with extracted text (status ok). Platform usage included. Scanned, empty and error rows are delivered for free. | $0.002 | $0.0015 |
$2.00 at the listed price, or $1.50 on higher Apify plans, for 1,000 document with extracted text units.
Prices from the Apify Store on 20 November 2026. Apify shows the final price before each run.
How it compares with other Apify actors
Price per 1,000 documents at Apify Store list prices. Every row is a live listing on the Store, read on 20 Nov 2026, so a buyer can check each number at the source.
| Actor | Price per 1,000 documents (Free plan) | Higher plans (Gold) | Start fee per run | Platform usage | Users | Rating | Last build |
|---|---|---|---|---|---|---|---|
| PDF Text Extractor This API | $2.00 | $1.50 | None | Included | 1 | No reviews yet | 18 Nov 2026 |
| PDF Text Extractor — PDF to Text, Pages & Metadata | $3.45 | $1.80 | None | Included | 703 | No reviews yet | 16 Nov 2026 |
| PDF Text Extractor - Multi-Column Layout, OCR & Metadata | $5.40 | $3.45 | None | Included | 4 | No reviews yet | 7 Sep 2026 |
| PDF to Text & Markdown: Extract PDF Content by URL | $2.00 | $1.52 | $0.003 | Included | 4 | No reviews yet | 26 Oct 2026 |
| PDF to Text API — Extract PDF Text to Clean JSON for LLM & RAG | Charges per PDF page extracted rather than per document. | None | Included | 5 | No reviews yet | 22 Aug 2026 | |
Where PDF Text Extractor — PDF to Text, Pages & Metadata is stronger
Where PDF Text Extractor — PDF to Text, Pages & Metadata is stronger
- Chunks long documents with continuation markers for RAG pipelines
- Follows paper and article pages through to their PDF
- Reports extraction status and a recommended action per document
Where this API is stronger
- Scanned image only PDFs are flagged rather than returned silently empty
- Table extraction as an optional field
- Platform usage included in the document price
Where PDF Text Extractor - Multi-Column Layout, OCR & Metadata is stronger
Where PDF Text Extractor - Multi-Column Layout, OCR & Metadata is stronger
- Layout aware text that reads multi-column pages in the right order
- Bookmarks, outline and hyperlinks extracted on request
- Optional OCR billed only for the pages it actually reads
Where this API is stronger
- One charge per document with no separate page component
- Scanned documents flagged with an isScanned field
- Platform usage included in the document price
Where PDF to Text & Markdown: Extract PDF Content by URL is stronger
Where PDF to Text & Markdown: Extract PDF Content by URL is stronger
- Markdown or plain text output with headings and tables rebuilt
- Extra pages billed separately, so short documents stay inexpensive
- Keyword include and exclude filters on the rows returned
Where this API is stronger
- Per document charge with no page ceiling built in
- Page level text array and optional table extraction
- Scanned image only files flagged rather than returned empty
Where PDF to Text API — Extract PDF Text to Clean JSON for LLM & RAG is stronger
Where PDF to Text API — Extract PDF Text to Clean JSON for LLM & RAG is stronger
- De-hyphenated, whitespace normalised text on every page
- One row per page, which suits chunking page by page
- Very little setup needed for a quick extraction
Where this API is stronger
- One row per document with metadata, so a long list stays manageable
- Optional page text arrays and tables in the same row
- Platform usage included in the document price
PDF text extraction looks simple but the units differ: per document, per PDF with a page component, or per page. The automation-lab listing is the best used of the group and adds chunking, while webdata_labs and omao price per page. Ours charges once per document, includes page text and tables, and flags scanned files instead of returning them empty.
Prices are Apify Store list prices, checked 20 Nov 2026. Platform usage 'Paid separately' means Apify bills compute on top of the event price. Check each listing before you buy.
How to run it
- Paste PDF links into urls, either as plain strings or as objects with a url field. Redirects are followed automatically.
- Set maxPages, for example 200, and maxFileSizeMb, for example 50, so a huge report cannot stall the run.
- Choose whether you need per-page text with includePageTexts and tables with includeTables.
- Set maxDocuments as the row cap, for example 100, then run the actor.
- Read text, pageTexts or tables per row, and export the dataset as JSON, CSV or Excel.
cURL
curl -X POST "https://api.apify.com/v2/acts/subimpact~pdf-text-extractor/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{"urls":[{"url":"https://www.irs.gov/pub/irs-pdf/fw9.pdf"},{"url":"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-145.pdf"},{"url":"https://arxiv.org/pdf/1706.03762"}]}'Python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("subimpact/pdf-text-extractor").call(run_input={"urls":[{"url":"https://www.irs.gov/pub/irs-pdf/fw9.pdf"},{"url":"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-145.pdf"},{"url":"https://arxiv.org/pdf/1706.03762"}]})
for item in client.dataset(run["default_dataset_id"]).iterate_items():
print(item)JavaScript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('subimpact/pdf-text-extractor').call({"urls":[{"url":"https://www.irs.gov/pub/irs-pdf/fw9.pdf"},{"url":"https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-145.pdf"},{"url":"https://arxiv.org/pdf/1706.03762"}]});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);MCP
claude mcp add subimpact-data -e APIFY_TOKEN=<YOUR_APIFY_TOKEN> -- npx -y @subimpact/data-mcp
# Then ask your agent to use the pdf_text tool.n8n
Use the Apify node (Run an Actor).
Actor ID: subimpact/pdf-text-extractor
Input JSON: paste the example input above.
MCP users: @subimpact/data-mcp exposes these actors as tools, so an agent can call pdf_text directly.
Limits
- No OCR, so image-only PDFs return their status without text.
- Password-protected PDFs cannot be opened and return an error row.
- Text is capped at 1,000,000 characters, with layout whitespace normalised.
- Downloads run one document at a time, so large batches take a while.
Questions people ask
What does a document cost?
A document that yields text costs $0.002, which is $2.00 per 1,000 documents, with the lowest tier at $0.15 per 1,000. Scanned, empty and error rows are delivered with their status and are free, so you pay only when a document actually produces text. Platform usage is included.
Does it read scanned PDFs with OCR?
No. There is no OCR in this version. Image-only documents are detected and flagged with isScanned true and status scanned or empty, and they are not charged. Send those files to an OCR service, and use this actor to identify exactly which ones need it.
Do I need an API key or a browser?
Neither. Each URL is downloaded over plain HTTP and parsed directly, with no browser, login or key. Downloads are sequential and streamed one document at a time with a size cap, so memory use stays around 100 MB in a typical text-only run.
How much text do I get from a long document?
text is capped at 1,000,000 characters, and truncated is set to true when the cap was hit. pagesExtracted shows how many pages were read against the real pageCount, so you can tell a short document from a long one that was cut by maxPages.
Are tables reliable?
Tables are returned as page and rows arrays of cell text, which handles straightforward grids well. Complex layouts with merged cells or overlapping text can lose structure, so treat table output as a starting point and check anything you plan to load into a database.
Why did a PDF come back as an error?
Common causes are a password-protected file, a link that no longer resolves, a file above maxFileSizeMb, or a download the host blocked. The error field carries the reason and the row is free. If a publisher blocks the platform IPs, enabling a proxy is the fix.
Does it preserve layout and columns?
No. Whitespace is normalised, so runs of spaces collapse and blank lines are dropped, which keeps text clean for an LLM but loses column alignment. Use tables for tabular data and pageTexts for page boundaries when layout matters to your downstream step.
Need a data source that is not here?
We build and run scrapers for sites that have no public API. Tell us the site, the fields and how often you need them.