PDFShift vs DocRaptor for HTML to PDF Conversion

PDFShift and DocRaptor both convert HTML to PDF through hosted APIs, but the available documentation does not establish a universal winner for rendering quality, speed, reliability, security, or cost. DocRaptor documents its use of the Prince PDF engine, selectable pipeline versions, and configurable JavaScript handling. PDFShift describes CSS and JavaScript support, webhooks, and parallel or asynchronous conversions. The right choice depends on how each renders your real documents, the job limits you need, and the full cost at your volume.

This guide compares their documented workflows and limits, gives runnable API examples, and lays out a repeatable evaluation. If your goal is a page screenshot rather than a paginated document, see ScreenshotNeo as an alternative to try first.

At a glance

Question	PDFShift	DocRaptor
Documented rendering details	Describes CSS and JavaScript support; the reviewed material does not identify an equivalent selectable engine and pipeline configuration.	Documents the Prince PDF engine, pipeline versions, and optional JavaScript engines.
Input and integration	Developer material describes raw HTML or URL input, webhooks, integrations, and parallel or asynchronous conversions.	Accepts HTML content or a URL; documents API-key authentication, asynchronous jobs, callbacks, and hosted document output.
Published limits in reviewed sources	Free plan lists 15 MB maximum file size and a 30-second timeout; pricing page advertises up to 50 free credits monthly. Credit use depends on output size.	One-minute default synchronous limit, ten-minute asynchronous limit, 30 simultaneous requests, and 100 MB hosted-document output limit.
Cost comparison	Free allowance and credit accounting are published; verify current plan details.	The reviewed evidence did not establish a current like-for-like paid price.
Evidence of a winner	No controlled head-to-head test or independent evidence in the reviewed sources establishes a quality, speed, reliability, security, or cost winner.

Vendor limits and plan details can change. Confirm them on the linked current documentation and pricing pages before choosing a plan.

How to choose between PDFShift and DocRaptor

Choose by rendering requirements, not feature labels

Make a small test set that represents your actual output: a simple invoice, a long report with page breaks, a document with custom fonts, a page with charts or SVG, and a page whose content depends on JavaScript. Compare the resulting PDFs visually and inspect whether text, links, fonts, headers, footers, and page breaks behave as expected.

DocRaptor identifies Prince as its PDF engine and exposes pipeline selection. That detail can help when you need to understand or control the rendering pipeline. PDFShift describes CSS and JavaScript support, but the reviewed evidence does not provide an independently measured comparison of how either service handles a particular CSS feature. Test the CSS you use instead of inferring fidelity from broad support claims. DocRaptor API reference · PDFShift developer page

Check whether JavaScript must run

DocRaptor documents two optional JavaScript engines, both disabled by default. Its reference warns that enabling both can evaluate code twice. If your HTML needs client-side rendering, determine which engine fits your page and enable only what is required; test for duplicate requests or side effects if both are enabled. PDFShift describes JavaScript support, but test delayed scripts, charts, and dynamically inserted content using the actual integration settings you plan to use.

Match the job model to your application

A synchronous request is convenient when a user is waiting for one small PDF. A background job is usually a better fit for long reports, bursts, or work that can be retried independently. DocRaptor documents asynchronous jobs and callbacks. PDFShift describes webhooks and parallel or asynchronous conversions. For either service, make the job state and retry behavior explicit in your application rather than assuming a slow conversion will finish within an HTTP request window.

Estimate the full cost

PDFShift advertises up to 50 free credits per month. Its pricing page says a credit covers up to 5 MB of generated output; its FAQ gives a 14 MB PDF as an example that consumes three credits. The listed free plan has a 15 MB maximum file size and a 30-second timeout. Those are vendor-published details, not a guarantee for every workload; confirm current terms and your plan’s limits on PDFShift pricing and its FAQ.

The reviewed research did not establish a current, comparable DocRaptor price. Do not declare either service cheaper from these figures alone. Estimate monthly document count, average and high-percentile output sizes, retries, and peak concurrency, then compare current plan costs for that workload.

PDFShift workflow and example

PDFShift’s developer material describes conversion from raw HTML or a URL, with options such as CSS and JavaScript injection, headers and footers, encryption, watermarking, AWS S3 delivery, and asynchronous or parallel responses. Availability may depend on the plan, so check its current developer documentation and pricing.

The following cURL example shows the basic shape for converting a URL. Use the authentication method and exact request fields specified in the current PDFShift documentation for your account:

curl -X POST "https://api.pdfshift.io/v3/convert/pdf" \
  -H "Content-Type: application/json" \
  -H "Authorization: Basic YOUR_API_KEY" \
  -d '{"source":"https://example.com/invoice/123"}' \
  --output invoice.pdf

Confirm the endpoint and authentication syntax against PDFShift’s current docs before using this sample in production; the research dossier describes its input modes and features but does not include a verified endpoint request schema.

DocRaptor workflow and example

DocRaptor documents POST requests to its document endpoint with API-key authentication. You can provide HTML content or a URL. A normal successful request returns PDF bytes; an asynchronous request returns a job status identifier, while a hosted-document request returns a download URL. Pipeline defaults and available engine versions can change, so check the API overview and API reference.

Example cURL request using URL input, with the API key supplied as HTTP Basic authentication:

curl -u "YOUR_API_KEY:" \
  -H "Content-Type: application/json" \
  -d '{"document_type":"pdf","document_url":"https://example.com/invoice/123","name":"invoice-123.pdf","test":true}' \
  "https://docraptor.com/docs" \
  --output invoice-123.pdf

The test setting and request fields should be checked against the current API reference for the environment and behavior you need. For raw HTML, use the documented document-content input field instead of document_url.

Limits, scripts, and operational behavior

DocRaptor limits

DocRaptor documents a one-minute default generation limit for synchronous calls and a ten-minute limit for asynchronous generation. It lists 30 simultaneous requests and a 100 MB output limit for hosted documents. Its limits page says it does not impose hard limits on pages, complexity, input size, or output size apart from the hosted-document limit. These statements describe API limits; your own application, network, plan, or practical rendering complexity can still constrain a job. See DocRaptor API limits.

PDFShift limits and credit accounting

The current pricing page lists a 15 MB maximum file size and 30-second timeout for the free plan and advertises up to 50 free credits monthly. Credit accounting is based on generated output size, not simply one credit per request. Inspect the current plan details and measure the PDFs your application generates before forecasting volume. See PDFShift pricing.

Reliability and retries

For asynchronous work, persist the provider’s job identifier and track completion through the documented status or callback flow.
Use bounded retries for transient network or service errors. Avoid retrying malformed HTML or invalid options unchanged.
Make your own job processing idempotent: a retry should not create duplicate invoices, emails, or downstream actions.
Log request identifiers, job identifiers, conversion duration, document size, and a sanitized error category. Do not log sensitive HTML or credentials by default.
Test callback verification and recovery behavior, including duplicate and delayed notifications, using the provider’s current guidance.

A fair comparison plan

Select representative documents. Include the shortest and longest documents, complex CSS, custom fonts, external assets, JavaScript-generated content, and expected edge cases.
Fix the inputs. Send equivalent HTML, CSS, assets, and rendering settings to both services. Pin pipeline or engine options where available.
Compare output. Review page count, pagination, layout, missing assets, text selection, links, and visual differences. Keep the source files and resulting PDFs for reproducibility.
Exercise failure cases. Try inaccessible URLs, slow assets, invalid markup, missing fonts, and jobs close to the documented time limits. Record status codes, error messages, and whether a job can be recovered.
Measure your workload. Run enough jobs to cover expected concurrency and volume. Track latency distributions and output sizes; do not treat an uncontrolled test as a vendor benchmark.
Calculate cost and operational work. Use current pricing, actual output sizes, likely retries, and the labor needed to handle asynchronous jobs and failures.
Review data handling. Read current terms and security documentation before sending confidential or regulated documents. PDFShift’s developer page makes claims about storage and HIPAA compliance; these are vendor statements, not independent verification. Verify current contractual and compliance documentation. Do the same due diligence for DocRaptor.

When the deliverable is a screenshot

HTML-to-PDF services are designed to produce paginated documents. If you need a rendered web page image for a preview, report thumbnail, or visual record, ScreenshotNeo is the alternative to try first. It is a website screenshot API and MCP server from Yorker Media. Its API returns PNG, JPEG, WebP, or PDF, and it offers controls such as full-page or element capture, viewport and device settings, custom CSS and JavaScript, and waiting for page conditions.

ScreenshotNeo also accepts cookie or consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each of those steps can be turned off. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, with response headers indicating the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients. Those capabilities suit screenshot and page-capture workflows; choose a dedicated HTML-to-PDF conversion service when you need its document rendering workflow and controls.

Or skip the browser setup

ScreenshotNeo turns a URL into a screenshot with one GET request. See the ScreenshotNeo API documentation for parameters and response options.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await Bun.write('shot.webp', new Uint8Array(await res.arrayBuffer()));

Cookie banners, popups, and chat widgets are removed before the shot. Bot checks, blank pages, and failed loads are never billed. An MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Sign up for free and get 1,000 screenshots a month with no card.

Troubleshooting

Symptom	Likely cause	What to do
PDF is missing content created in the browser	JavaScript did not run, ran too early, or depended on a resource unavailable to the renderer.	For DocRaptor, review the JavaScript engine options and enable only what the page needs; both are disabled by default and enabling both may run code twice. For either service, ensure scripts and assets are reachable and test delayed content.
Layout or page breaks differ from the browser	HTML-to-PDF rendering has different pagination and CSS behavior than a screen viewport.	Reduce the case to a small HTML fixture, inspect print-specific CSS and page-break rules, then compare that fixture in each provider.
External images or fonts are absent	The conversion service cannot fetch the asset, or the resource is protected or slow.	Check asset URLs, access controls, and response behavior from a server-side environment. Use accessible assets or embed them where appropriate.
Synchronous conversion times out	The document takes longer than the synchronous window, or external resources are delaying rendering.	Use an asynchronous job for long-running work. DocRaptor documents a ten-minute asynchronous limit; for PDFShift, check current plan and API limits.
PDFShift job consumes more credits than expected	Credits are based on generated output size; large documents can consume multiple credits.	Measure output sizes, consult the current credit rules, and include large-document cases in the cost estimate.
DocRaptor output or engine behavior changes	A pipeline default or engine version may have changed, or the request selected a different pipeline.	Check the current API reference, specify the desired supported pipeline where appropriate, and keep a regression PDF set.
Async job callback is missed or handled twice	Callbacks can arrive late, be retried, or collide with a temporary application failure.	Persist job state, make callback processing idempotent, and provide a reconciliation path using the documented status workflow.
Provider returns an error for valid-looking HTML	An option may be unsupported, the URL may be inaccessible, or the HTML may rely on browser-only state.	Inspect the provider’s response body and request ID, reduce the HTML to a minimal reproduction, and verify the exact request schema in current docs.

Cost, performance, and security notes

Cost: Compare the same monthly document count and output size against current plans. Include retries, large files, and overage rules. PDFShift’s free credits are output-size based; the dossier does not provide a comparable current DocRaptor price.
Performance: Do not rely on a single timing run. Rendering time depends on document complexity, JavaScript, and external resources. Benchmark representative documents at the concurrency your application expects.
Reliability: Keep synchronous calls for jobs that fit the user interaction. Use asynchronous flows for longer work and define timeouts, retries, and reconciliation.
Security: Treat HTML, URLs, credentials, and generated documents as sensitive inputs. Review current retention, access, compliance, and contractual terms before processing sensitive material. Vendor-published privacy or compliance claims are not an independent audit.
Resource control: Avoid giving a conversion endpoint unrestricted access to user-supplied URLs without considering internal network and data exposure risks. Validate allowed inputs and follow the provider’s current security guidance.

FAQ

Does DocRaptor require a URL?

No. Its API reference documents HTML content or URL input.

Does DocRaptor run JavaScript by default?

No. Its documentation says both JavaScript engines are disabled by default.

Does PDFShift charge one credit per PDF?

Not necessarily. Its published credit rule is based on generated output size, with up to 5 MB covered by a credit.

Which service is faster?

The reviewed sources do not establish a speed winner. Measure your own representative documents and concurrency.

Are either provider’s security claims independently verified here?

No. The claims in the reviewed material are vendor statements. Consult current agreements and security documentation directly.

Sources

PDFShift pricing and FAQ for published credits and plan limits.
PDFShift developer page for described conversion features and vendor data-handling claims.
DocRaptor API reference, API overview, and API limits.