PDF.co vs pdf2json: Node.js PDF Parsing Compared

PDF.co vs pdf2json: Which PDF-to-JSON Solution Should You Use?

PDF.co and pdf2json can both produce JSON from PDF documents, but the similarity largely ends there.

pdf2json is an open-source Node.js parser. It processes PDFs locally and converts their text, coordinates, page elements, metadata, and interactive form information into a detailed JSON representation.

PDF.co is a hosted document-processing API. It can convert PDFs to JSON, but it also provides OCR, AI invoice parsing, table and field extraction, format conversion, PDF generation, editing, form filling, barcode processing, and integrations with automation platforms.

The short answer:

  • Choose pdf2json when you need free, local parsing of digitally generated PDFs in a Node.js application.
  • Choose PDF.co when scanned documents require OCR or when the output must contain meaningful fields, tables, or invoice data.
  • Choose PDF.co when PDF-to-JSON is only one part of a larger document workflow.
  • Consider using both when local parsing can handle simple PDFs and PDF.co can process documents that require OCR or more advanced extraction.

What Is pdf2json?

pdf2json is an Apache-licensed Node.js module that converts PDF binaries into JSON and text.

It is based on a Node.js port of Mozilla’s PDF.js technology and is designed for server-side and command-line processing.

Its primary capabilities include:

  • Extracting embedded PDF text
  • Returning text coordinates
  • Returning page dimensions
  • Describing horizontal and vertical lines
  • Describing filled areas
  • Returning font and style information
  • Reading PDF metadata
  • Parsing interactive form elements
  • Reading existing form-field values
  • Extracting raw text
  • Processing files through a command-line interface
  • Parsing PDF buffers
  • Supporting stream-based parsing

Unlike an API client, pdf2json contains the parsing code and processes the file in the application’s environment.

The project remains active. At the time of review, the current version was 4.0.3, released in April 2026. Version 4 requires Node.js 20.18.0 or later and provides both CommonJS and ES module builds, along with TypeScript declarations.

Current source code and documentation are available in the pdf2json GitHub repository.

What Is PDF.co?

PDF.co is a hosted API platform for PDF extraction, conversion, generation, and editing.

Its capabilities include:

  • PDF-to-JSON
  • PDF-to-CSV
  • PDF-to-XML
  • PDF-to-Excel
  • PDF-to-text
  • PDF-to-HTML
  • PDF-to-image
  • OCR for scanned PDFs and images
  • AI invoice parsing
  • Template-based document parsing
  • HTML-to-PDF
  • URL-to-PDF
  • Email-to-PDF
  • Word, Excel, image, and document-to-PDF conversion
  • PDF merging and splitting
  • PDF compression
  • Form filling
  • Text and image addition
  • Text search, replacement, and deletion
  • Password addition and removal
  • Barcode and QR code reading and generation
  • Document classification
  • Page deletion and rotation

PDF.co can be called from Node.js or any other environment that supports HTTPS. It also offers integrations for platforms such as Zapier, Make, and n8n.

The current endpoints are listed in the PDF.co API documentation.

The Main Difference: PDF Structure vs Business Data

The most important distinction is what “PDF to JSON” means.

What pdf2json returns

pdf2json produces a structural representation of a PDF.

Its JSON can include:

  • Pages
  • Page height and width
  • Text blocks
  • Text runs
  • X and Y coordinates
  • Alignment
  • Font and style references
  • Horizontal lines
  • Vertical lines
  • Filled rectangles
  • Form fields
  • Checkboxes
  • Radio-button groups
  • Dropdown values
  • Signature-field information
  • Document metadata

This output tells a developer where PDF elements are located and how they are represented.

It does not automatically tell the developer that a value is:

  • An invoice number
  • A vendor name
  • A purchase-order number
  • A transaction date
  • A subtotal
  • A tax amount
  • An invoice total
  • A line-item description

The developer must write rules to transform the layout data into meaningful business fields.

What PDF.co can return

PDF.co supports several kinds of JSON output.

A general PDF-to-JSON conversion can expose text and document information. Document Parser can extract named fields, tables, values, and barcodes according to reusable rules. AI Invoice Parser can return invoice-specific fields without requiring a template.

This means PDF.co can return JSON closer to:

{ "invoiceNumber": "INV-10452", "invoiceDate": "2026-07-15", "vendor": "Example Supply Company", "purchaseOrder": "PO-8831", "subtotal": 925.00, "tax": 74.00, "total": 999.00 }

By comparison, pdf2json may return the text and coordinates from which those values must be inferred.

Choose pdf2json when you need the PDF’s layout data. Choose PDF.co when you need the document’s business data.

Is pdf2json Still Maintained?

Yes. Unlike some older PDF-related npm packages, pdf2json remains under active development.

At the time of review:

  • The current package version was 4.0.3.
  • Version 4.0.3 was released in April 2026.
  • The repository contained more than 400 commits.
  • The project had approximately 2,200 GitHub stars.
  • The package had no runtime dependencies.
  • The project provided automated tests and a large collection of PDF form samples.
  • Both CommonJS and ES module builds were included.
  • TypeScript declarations were included.

The project is maintained by its community and primary maintainer rather than a commercial support organization. Its documentation notes that the maintainer works on the project in spare time.

This distinction matters for production use. An active open-source package can be reliable, but it does not provide the same contractual support, service commitments, or managed infrastructure as a commercial API.

Local Processing

Local processing is one of pdf2json’s biggest advantages.

A Node.js application can parse a PDF from a file:

import fs from "node:fs"; import PDFParser from "pdf2json"; const parser = new PDFParser(); parser.on("pdfParser_dataError", ({ parserError }) => { console.error(parserError); }); parser.on("pdfParser_dataReady", (pdfData) => { fs.writeFileSync( "output.json", JSON.stringify(pdfData, null, 2) ); }); parser.loadPDF("document.pdf");

It can also parse a buffer:

const pdfBuffer = fs.readFileSync("document.pdf"); parser.parseBuffer(pdfBuffer);

The document does not need to be sent to an external service unless the application itself does so.

Local processing can be useful when:

  • Documents cannot leave the organization’s infrastructure.
  • The application must work without internet access.
  • A private network is used.
  • Processing volume is high and predictable.
  • The team wants to avoid per-document API charges.
  • A Node.js runtime is already available.
  • The team can operate and monitor the parser itself.

PDF.co’s standard model is hosted processing. The application sends the document or a document URL to PDF.co and receives the result.

The hosted model reduces infrastructure work, but organizations should review security, retention, processing location, and contractual requirements before sending sensitive documents.

Node.js and Runtime Support

The current pdf2json package requires Node.js 20.18.0 or later.

Version 4 provides:

  • An ES module build
  • A CommonJS build
  • TypeScript declarations
  • A command-line executable
  • Buffer parsing
  • File parsing
  • Stream-related interfaces

Applications using older releases should review the project’s breaking changes before upgrading. The import syntax and exported modules changed during the transition from CommonJS to ES modules and later dual-module builds.

Do not upgrade a production application blindly. Test:

  • Import statements
  • Events
  • Output structure
  • Form-field results
  • Error handling
  • Stream behavior
  • Node.js runtime compatibility
  • TypeScript compilation
  • Existing JSON transformation logic

PDF.co can be called from Node.js without installing a specialized parser. Developers can use the built-in fetch API or another maintained HTTP client.

Because PDF.co is language-independent, the same document service can be called from:

  • Node.js
  • Python
  • PHP
  • Java
  • C#
  • Go
  • Serverless platforms
  • Low-code automation tools

JSON Output from pdf2json

The primary pdf2json output describes each page and its elements.

A simplified result may resemble:

{ "Transcoder": "pdf2json@4.0.3", "Meta": { "PDFFormatVersion": "1.7", "Author": "Example Author", "Creator": "Example Application" }, "Pages": [ { "Width": 38.25, "Height": 49.5, "Texts": [ { "x": 4.5, "y": 6.2, "R": [ { "T": "Invoice%20Number", "S": -1, "TS": [0, 12, 1, 0] } ] } ] } ] }

The exact schema includes compact field names and dictionaries intended to reduce payload size.

For example:

  • Texts contains text blocks.
  • x and y describe positions.
  • R contains text runs.
  • T contains encoded text.
  • TS describes font and style information.
  • HLines describes horizontal lines.
  • VLines describes vertical lines.
  • Fills describes filled areas.
  • Fields and Boxsets contain interactive form information.

This output is useful for developers who need low-level access to a PDF’s layout.

It may be cumbersome when a downstream system expects clean domain-specific JSON. Additional decoding, grouping, sorting, and interpretation are normally required.

Text Extraction

pdf2json can return raw text through getRawTextContent() or its command-line content option.

For example:

const parser = new PDFParser(null, 1); parser.on("pdfParser_dataReady", () => { const text = parser.getRawTextContent(); console.log(text); }); parser.loadPDF("document.pdf");

The command-line interface can also produce a .content.txt file:

pdf2json -f document.pdf -c

Raw text extraction removes most layout and style information. It may be sufficient for:

  • Full-text search
  • Keyword detection
  • Basic indexing
  • Feeding clean text into another application
  • Checking whether a PDF contains a phrase

It may not be sufficient for:

  • Multi-column documents
  • Tables
  • Invoices
  • Financial statements
  • Forms without populated interactive fields
  • Documents with unusual reading order
  • Scanned pages

PDF.co provides PDF-to-text conversion and can apply OCR when the page does not contain a usable text layer.

OCR and Scanned PDFs

pdf2json is not an OCR engine.

It extracts text and other objects already encoded in the PDF. If a page contains only a scanned image, there may be no text for the parser to extract.

The appearance of OCR-related font names in its internal style dictionaries does not mean the package recognizes characters from images.

A PDF needs OCR when:

  • Text cannot be selected in a PDF viewer.
  • The document came from a scanner.
  • Each page is a photograph.
  • The file contains faxed pages.
  • Text extraction returns empty or nearly empty results.
  • Search does not find visible words.

PDF.co includes OCR for scanned PDFs and images.

A PDF.co workflow can:

  • Recognize text in page images.
  • Return OCR results as text or structured output.
  • Produce a searchable PDF.
  • Extract fields and tables after OCR.
  • Convert recognized content into JSON, CSV, XML, or Excel.
  • Read barcodes from scanned pages.

Choose PDF.co when scanned documents are part of the expected input. Alternatively, pair pdf2json with a separate OCR engine, accepting the added deployment and integration work.

Table Extraction

pdf2json exposes text coordinates and graphical lines that a developer can use to reconstruct tables.

For example, an application could:

  • Group text by similar Y coordinates.
  • Sort each row by X coordinate.
  • Detect vertical lines as column boundaries.
  • Detect horizontal lines as row boundaries.
  • Merge broken text runs.
  • Apply tolerances for alignment differences.
  • Map the resulting cells into a custom schema.

This can work for stable, predictable table layouts.

However, pdf2json does not automatically turn every visual table into clean rows and columns. PDFs often store table text as individually positioned elements without semantic information identifying headers, cells, or rows.

Challenges include:

  • Borderless tables
  • Wrapped cells
  • Merged columns
  • Repeated headers
  • Tables spanning pages
  • Variable row heights
  • Missing lines
  • Multiple tables on one page
  • Rotated text
  • Scanned tables

PDF.co can convert PDF tables to CSV or Excel and can use Document Parser to extract configured table regions.

For a simple table with consistent geometry, custom pdf2json logic may be economical. For variable documents or business-critical extraction, PDF.co can reduce the amount of parsing code the team must maintain.

Invoice Extraction

pdf2json can expose the words, coordinates, lines, and metadata contained in an invoice. It does not inherently understand invoice semantics.

To extract an invoice number, a developer might:

  • Find a text block containing “Invoice Number.”
  • Search nearby text blocks.
  • Compare their coordinates.
  • Decode the text.
  • Validate the result with a regular expression.
  • Add vendor-specific exceptions.
  • Repeat the process for dates, totals, and line items.

This approach can work when every invoice follows one layout.

It becomes more difficult when:

  • Many vendors use different designs.
  • Labels vary by language.
  • Values move between pages.
  • Line-item tables differ.
  • Invoices are scanned.
  • The same number format appears in several places.
  • Credit notes and statements enter the same workflow.

PDF.co’s AI Invoice Parser is designed to return structured invoice fields without requiring a template. Document Parser is available when explicit extraction rules are preferred.

Choose PDF.co for varied invoice streams. Consider pdf2json when the layout is fixed, the PDF contains digital text, and the team is comfortable maintaining extraction rules.

Interactive PDF Forms

PDF form parsing is one of pdf2json’s notable strengths.

It can extract information about interactive elements such as:

  • Text fields
  • Checkboxes
  • Radio-button groups
  • Dropdown lists
  • Link buttons
  • Signature fields
  • Field values
  • Required and read-only attributes
  • Field positions
  • Selected options
  • Certain field format definitions

The project includes a substantial collection of government PDF forms in its test suite.

For example, getAllFieldsTypes() can produce a simplified list of form fields:

parser.on("pdfParser_dataReady", () => { const fields = parser.getAllFieldsTypes(); console.log(fields); });

A field result may identify:

  • Field ID
  • Field type
  • Whether it is calculated or read-only
  • Existing value

pdf2json reads form information. It is not a complete API for filling, modifying, flattening, or delivering forms.

PDF.co can inspect supported PDF fields and fill them using its PDF Add/Edit capabilities. It can also add text or images when a PDF lacks an interactive field.

Choose pdf2json when local form inspection is the requirement. Choose PDF.co when the workflow needs both field discovery and document modification.

Signature Fields

pdf2json can identify a PDF signature field and return available metadata from an existing signature, such as:

  • Signer name
  • Signing time
  • Location
  • Reason
  • Contact information

This does not mean that pdf2json validates the cryptographic signature, verifies a signer’s identity, or provides an electronic-signature ceremony.

PDF.co can place a supplied signature image or other visible content into a PDF. A dedicated signing platform may still be required for:

  • Recipient authentication
  • Signing invitations
  • Multiple signers
  • Signing order
  • Consent records
  • Audit trails
  • Cryptographic validation
  • Completion certificates

PDF Editing and Generation

pdf2json is a parser. It does not provide a full PDF editing or generation toolkit.

It is not intended to:

  • Generate PDFs from HTML
  • Convert webpage URLs to PDF
  • Convert Word or Excel files into PDF
  • Merge arbitrary documents
  • Split PDFs
  • Compress PDFs
  • Replace text
  • Add watermarks
  • Fill forms
  • Add passwords
  • Rotate or delete pages

PDF.co provides APIs for those operations.

This difference matters when extraction is only one stage of the application.

A PDF.co workflow can:

  • Extract an invoice number.
  • Add that number to the original PDF.
  • Merge the invoice with a purchase order.
  • Compress the combined document.
  • Protect it with a password.
  • Send the final file to storage.

With pdf2json, the application would need additional libraries or services for every modification.

PDF-to-Image Conversion

pdf2json returns page structure rather than ready-to-use page images.

PDF.co can convert PDF pages into formats such as:

  • JPG
  • PNG
  • TIFF

PDF-to-image is useful for:

  • Document previews
  • Thumbnails
  • Vision-model input
  • Archival workflows
  • Browser display
  • OCR preparation
  • Systems that do not accept PDF input

If the application needs both local text extraction and page rendering, pdf2json must be paired with a separate rendering library.

Barcode and QR Code Processing

pdf2json can expose embedded text and page geometry, but it does not provide a general barcode-recognition engine.

PDF.co can read and generate supported one-dimensional and two-dimensional barcodes.

This supports workflows such as:

  • Separating scanned batches
  • Routing forms
  • Reading shipment numbers
  • Matching documents to database records
  • Extracting QR-code data
  • Generating cover sheets and labels

Command-Line Use

pdf2json can be installed globally and used from a terminal:

npm install -g pdf2json pdf2json -f document.pdf -o output

Current command-line options include controls for:

  • Input files or directories
  • Output directories
  • Raw text output
  • Form-field output
  • Merged text blocks
  • Stream-based processing
  • Reusing a parser for batch processing
  • JSON summaries
  • Quiet or silent output

This can be useful for:

  • Local batch conversion
  • Data-preparation scripts
  • Testing PDF files
  • Internal utilities
  • Build pipelines
  • Offline processing

The command-line tool’s JSON summary describes the processing operation and output files. It should not be confused with the full parsed PDF JSON stored in the generated result.

Performance and Scaling

pdf2json runs on infrastructure controlled by the application team.

Performance therefore depends on:

  • CPU
  • Available memory
  • Node.js version
  • PDF size
  • Number of pages
  • Document complexity
  • Number of concurrent jobs
  • Whether files are processed as buffers or streams
  • Application-level queueing
  • Parser reuse
  • Error isolation

The current CLI provides stream and singleton options intended to improve control during batch processing.

For production use:

  • Limit input file size.
  • Limit concurrent parsing jobs.
  • Use worker processes or queues.
  • Set memory limits.
  • Treat uploaded PDFs as untrusted input.
  • Add request timeouts.
  • Isolate parser failures.
  • Test malformed and encrypted PDFs.
  • Monitor process memory.
  • Avoid blocking the application’s request loop with large batches.

PDF.co handles the parser infrastructure and supports asynchronous processing for longer-running jobs. The customer still needs retries, callbacks, usage monitoring, and failure handling.

Reliability and Difficult PDFs

No PDF parser handles every file perfectly.

The pdf2json test suite includes files associated with issues such as:

  • Unsupported encryption
  • Invalid cross-reference entries
  • Invalid cross-reference streams
  • Excessive line breaks
  • Broken text blocks

The project provides error events and tests designed to catch many failures. However, applications should expect some PDFs to produce incomplete results or exceptions.

Test with:

  • Encrypted documents
  • Malformed PDFs
  • Very large files
  • Unusual fonts
  • Character shaping
  • Right-to-left languages
  • Vertical text
  • Rotated pages
  • XFA forms
  • Signed documents
  • PDFs produced by old scanners
  • PDFs produced by browser print functions
  • Mixed scanned and digital pages

PDF.co also requires testing with representative files. A hosted service reduces parser maintenance but does not eliminate variation between PDF producers.

Security Considerations

Local processing does not automatically make an application secure.

PDF files are complex, potentially hostile inputs. An application using pdf2json should:

  • Keep Node.js and the package updated.
  • Validate MIME type and file signatures.
  • Limit file size and page count.
  • Run parsing with restricted permissions.
  • Isolate parsing from critical application processes.
  • Apply CPU and memory limits.
  • Avoid trusting filenames.
  • Delete temporary files.
  • Record parser failures without exposing sensitive content.
  • Monitor the project’s security and release history.

The current package has zero runtime dependencies, which reduces—but does not eliminate—software supply-chain exposure.

For PDF.co, review:

  • API-key storage
  • Encryption in transit
  • Temporary file retention
  • Output-link expiration
  • Processing regions
  • Access controls
  • Security documentation
  • Subprocessors
  • Data-processing agreements
  • Deletion procedures

Never embed a PDF.co API key in browser-side JavaScript.

Integrations and Automation

pdf2json is a Node.js package. Integration with another system must be built in code.

For example, a developer can parse a PDF and then send the result to:

  • A database
  • An ERP
  • A search index
  • An AI model
  • A CRM
  • Cloud storage
  • A message queue

PDF.co can be used directly through code and through automation platforms such as:

  • Zapier
  • Make
  • n8n
  • Microsoft Power Automate
  • Google Apps Script
  • Bubble
  • RPA tools

PDF.co may therefore be easier for mixed technical and nontechnical teams.

Licensing and Support

pdf2json is licensed under Apache License 2.0.

There is no charge for installing or running the package. The organization remains responsible for:

  • Infrastructure
  • Development
  • Scaling
  • Monitoring
  • Security
  • Upgrades
  • Error handling
  • Extraction rules
  • Production support

The project is community-maintained, and the primary maintainer states that it is developed in spare time. There is no standard commercial service-level agreement.

PDF.co is a commercial hosted service. Its subscription price includes use of the API infrastructure, while usage is measured through credits.

Pricing

pdf2json pricing

pdf2json is free to use under Apache License 2.0.

Its real cost may include:

  • Developer time
  • Server or serverless compute
  • Memory
  • Storage
  • Logging
  • Monitoring
  • Queue infrastructure
  • OCR software
  • Table-reconstruction code
  • Invoice-extraction rules
  • Maintenance
  • Incident response

For simple, local extraction, these costs may be minimal. For varied production documents, maintaining the surrounding system can become more expensive than the parser itself.

PDF.co pricing

PDF.co uses credits. Credit consumption depends on the endpoint, operation, and page count.

At the time of review, annual-billing prices include:

  • Basic: $8.99 per month with 16,500 credits
  • Personal: $22.49 per month with 37,000 credits
  • Business 1: $44.99 per month with 80,500 credits
  • Business 2: $89.99 per month with 159,850 credits
  • Business 3: $270 per month with 483,000 credits
  • Enterprise: Custom pricing

Confirm current prices and calculate the required operations on the PDF.co pricing page.

Include OCR, extraction, conversion, retries, testing, and traffic spikes in the estimate.

Where pdf2json Is Stronger

pdf2json is likely the better choice when:

  • Documents must remain inside your environment.
  • The application already uses Node.js 20.18 or later.
  • PDFs contain embedded digital text.
  • Low-level coordinates and style data are required.
  • Interactive form fields need to be inspected locally.
  • The team wants an Apache-licensed parser.
  • No per-page processing fee is desired.
  • The team can manage infrastructure and parser errors.
  • The document layout is consistent.
  • The team is comfortable writing its own extraction logic.
  • Offline operation is required.

Where PDF.co Is Stronger

PDF.co is likely the better choice when:

  • Scanned PDFs need OCR.
  • Invoices need to be converted into structured data.
  • Tables must be exported to CSV or Excel.
  • Documents vary significantly in layout.
  • PDFs must be converted to JSON, XML, HTML, text, or images.
  • HTML, URLs, email, images, or Office files must be converted into PDF.
  • PDFs need to be merged, split, compressed, protected, or edited.
  • Forms need to be filled as well as inspected.
  • Barcodes must be read or generated.
  • Zapier, Make, or n8n will be used.
  • The team wants managed processing and commercial support.
  • The application is written in more than one programming language.

Can pdf2json and PDF.co Be Used Together?

Yes.

A hybrid workflow can use local parsing first and send only difficult documents to PDF.co.

For example:

  • Receive a PDF.
  • Run pdf2json locally.
  • Check whether meaningful text was extracted.
  • If the PDF has a usable text layer, continue locally.
  • If the result is empty, send the document to PDF.co for OCR.
  • If the document is an invoice, use AI Invoice Parser.
  • If a table is required, use PDF.co’s CSV, Excel, or Document Parser options.
  • Store all results in one internal schema.

Another combined workflow could:

  • Use pdf2json to inspect local form fields.
  • Map database values to those fields.
  • Use PDF.co to fill and flatten the form.
  • Merge supporting documents.
  • Compress the final package.

A hybrid strategy can control cost while preserving advanced processing for documents that need it.

Questions to Ask Before Choosing

Before selecting PDF.co or pdf2json, ask:

  • Must documents remain inside our infrastructure?
  • Does every PDF contain a usable text layer?
  • Do we need OCR?
  • Do we need raw layout data or named business fields?
  • Are text coordinates required?
  • Do we need table extraction?
  • Are invoices from many vendors involved?
  • Must PDF forms be inspected or also filled?
  • Do we need PDF-to-image conversion?
  • Will documents need editing after extraction?
  • Do we need barcode recognition?
  • What Node.js versions are supported?
  • Can the team manage parser failures and scaling?
  • Is commercial support required?
  • What are the expected monthly pages and file sizes?
  • How much custom extraction logic will be required?
  • What is the cost of maintaining local infrastructure?
  • Can both products be tested against representative documents?

Frequently Asked Questions

Is pdf2json free?

Yes. It is available under Apache License 2.0.

Infrastructure, development, and maintenance costs still apply.

Is pdf2json actively maintained?

Yes. Version 4.0.3 was current when this page was reviewed and was released in April 2026.

What Node.js version does pdf2json require?

Version 4.0.3 declares Node.js 20.18.0 or later.

Does pdf2json process documents locally?

Yes. It parses PDF files or buffers inside the application environment.

Does pdf2json use OCR?

No. It extracts text already encoded in the PDF. Scanned image-only documents require a separate OCR engine or a service such as PDF.co.

Does pdf2json really convert a PDF to JSON?

Yes, but its JSON primarily describes the PDF’s pages, text blocks, coordinates, styles, lines, fills, metadata, and form elements.

It does not automatically convert every document into clean business fields.

Can pdf2json extract tables?

It provides text coordinates and line information that developers can use to reconstruct tables. It does not guarantee automatic semantic table extraction.

PDF.co provides PDF-to-CSV, PDF-to-Excel, and configurable table extraction.

Can pdf2json extract invoice data?

It can expose the text and coordinates in an invoice. The developer must identify and normalize fields.

PDF.co provides an AI Invoice Parser for structured invoice extraction.

Can pdf2json read PDF form fields?

Yes. It can parse supported text fields, checkboxes, radio-button groups, dropdown lists, link buttons, signature fields, and field values.

Can pdf2json fill PDF forms?

No. It is primarily a parser.

PDF.co can inspect and fill supported form fields through its API.

Can pdf2json convert PDF pages to JPG?

Not as its primary function. A separate rendering library is required.

PDF.co provides PDF-to-image conversion.

Is pdf2json safer because it has zero dependencies?

Zero runtime dependencies reduce part of the dependency-chain risk. The package and its PDF parsing engine still process complex, potentially hostile input and must be updated, isolated, and monitored.

Which is better for a serverless application?

It depends on file size, runtime limits, memory, and security requirements.

pdf2json avoids an external API call but consumes the serverless function’s CPU and memory. PDF.co moves processing to a hosted service but introduces network requests and usage charges.

Which is cheaper?

pdf2json has no license or page fee, making it attractive for simple local parsing.

PDF.co charges by credits but can reduce the engineering and infrastructure needed for OCR, extraction, conversion, editing, and workflow integrations.

Final Verdict

pdf2json is an actively maintained, zero-dependency Node.js parser for converting PDF structure, text, metadata, and form elements into JSON. It is a strong option when documents contain embedded text, processing must remain local, and developers are prepared to interpret the output themselves.

PDF.co is a broader commercial document-processing API. It is the stronger choice when the workflow requires OCR, invoice parsing, structured table or field extraction, PDF conversion, editing, form filling, barcodes, or no-code integrations.

Choose pdf2json when you need the PDF’s structure.

Choose PDF.co when you need the document’s meaning or need to continue processing the file.

To evaluate PDF.co with your own Node.js application, create a PDF.co account and review the available endpoints in the PDF.co API documentation.