Html2Pdf.app vs PDFCrowd: Features, Limits, and Pricing

HTML2PDF.app and PDFCrowd are hosted APIs that convert web pages or HTML into PDF. HTML2PDF.app may fit if you want a JSON request, a documented callback workflow, or its larger stated output allowance per credit. PDFCrowd may fit if you need HTML uploads or documented options such as PDF/A and tagged PDF. Their credits use different output-size units, so compare expected PDF sizes, concurrency, and required features rather than comparing credit counts directly. Neither vendor’s published feature list proves which will render your particular documents more accurately.

Prices and plan limits below are the amounts listed on the vendors’ pages accessed October 3, 2026. They can change; confirm the exact billing period, taxes, and limits at checkout. This comparison is based on vendor documentation, not hands-on testing.

1. Quick comparison

Decision point	HTML2PDF.app	PDFCrowd
Request style	JSON POST to https://api.html2pdf.app/v1/generate, authenticated with an X-API-Key header.	Form-encoded HTTP request to the versioned endpoint https://api.pdfcrowd.com/convert/24.04/, using HTTP Basic authentication.
Inputs	Public URL or raw HTML.	Reachable URL, HTML text, or uploaded HTML file/archive.
Async workflow	Documented callback flow using callBackUrl.	The sources reviewed here do not establish an equivalent callback workflow.
Credit unit	One credit per 5 MB chunk of generated PDF.	One credit per 0.5 MB of output.
Free or trial entry	Free plan: 100 credits/month, one parallel conversion, PDF output up to 1 MB.	API trial: 100 credits valid for one month. The listed Nano plan is $1/month for 10 credits.
Limits documented here	Paid plans list unlimited PDF size; parallel conversions vary by plan.	Maximum upload is 300 MB and server-side processing is limited to 60 seconds. These are not an output PDF size limit.
Notable documented features	Chromium rendering, customization, callback workflow, and AES PDF encryption.	JavaScript readiness controls, protected content, PDF/A, and tagged PDF, among other output controls.

Sources: HTML2PDF.app documentation, HTML2PDF.app pricing, PDFCrowd API page, PDFCrowd HTTP guide, and PDFCrowd pricing. Verify current pages before choosing a plan.

2. API and input differences

HTML2PDF.app: JSON, API key, URL or HTML

The documented API uses an authenticated POST request to https://api.html2pdf.app/v1/generate. Supply the API key in the X-API-Key header and pass either a public URL or raw HTML in the JSON body. A normal request returns PDF bytes. If you provide callBackUrl, the documented flow is asynchronous and the callback payload carries a base64-encoded PDF.

The vendor identifies Chromium as its rendering engine. Its documentation notes that CSS media selection, available fonts and resources, and JavaScript timing can affect the output. Treat remote asset access and readiness as things to validate with your own document.

PDFCrowd: form fields, Basic authentication, multiple input routes

PDFCrowd’s HTTP guide documents the versioned endpoint https://api.pdfcrowd.com/convert/24.04/. Authenticate using HTTP Basic with your account username and API key, and submit form-encoded fields. You can provide a reachable URL, HTML in the text field, or an uploaded HTML file/archive. A successful response contains PDF bytes.

The broader API page lists a template input route as well. Check the current documentation for the exact parameters and constraints for your chosen input and integration. Do not assume the two products accept interchangeable request bodies.

3. Features that may decide the choice

Need	Documented fit	What to verify
Convert an existing public page	Both accept URL input.	Test login state, remote assets, fonts, scripts, redirects, and the desired print or screen styling.
Submit generated HTML	Both document HTML input; PDFCrowd also documents file/archive upload.	Check how relative assets resolve and whether your packaging approach is accepted.
Process asynchronously	HTML2PDF.app documents a callback workflow via callBackUrl.	If PDFCrowd async processing is mandatory, confirm its current API support directly; it is not established by the sources cited here.
Control page layout	Both document page customization. PDFCrowd lists page size, orientation, margins, page breaks, headers/footers, and page numbers; HTML2PDF.app’s converter exposes format, orientation, margins, scale, media type, wait timing, and header/footer options.	Render representative long documents and check page breaks, repeated elements, and print CSS.
Wait for dynamic content	Both document JavaScript-related controls; PDFCrowd lists readiness controls, while HTML2PDF.app documents load timing customization.	Determine a readiness condition for charts, client-rendered content, and delayed images. A fixed delay can waste time or still finish too early.
Restrict or protect a PDF	HTML2PDF.app documents PDF encryption with a user password and configurable permissions, including printing, copying, modifying, form filling, and page assembly. PDFCrowd lists password protection.	Confirm supported encryption/security requirements and test with the PDF viewers your recipients use. Password restrictions do not replace access control for the source document.
Archival or accessible output	PDFCrowd lists PDF/A and tagged PDF output.	Validate the specific archival profile or accessibility requirements with a suitable validator and review the resulting document.
Integrate a user-facing save button or automation	PDFCrowd lists WebSave, WordPress, Zapier, and Make integrations; HTML2PDF.app lists an online converter, playground, and WordPress plugin.	These are distinct products and entry points. Confirm whether the user-triggered workflow or backend API matches your use case.

These are documented capabilities, not evidence that every option behaves identically on every input. For HTML2PDF.app’s data-handling statements, the vendor says generated PDFs are processed temporarily rather than permanently stored, raw submitted HTML/text is not stored in conversion logs, and selected request metadata and submitted source URLs may be retained. Treat those as vendor statements rather than independently audited guarantees; review its current documentation and your own data requirements.

4. Limits, credits, and listed pricing

HTML2PDF.app plans

Listed plan	Monthly price	Credits/month	Parallel conversions	Output size
Free	$0	100	1	Up to 1 MB
Startup	$9	1,000	3	Unlimited PDF size
Standard	$25	5,000	10	Unlimited PDF size
Scale	$39	10,000	20	Unlimited PDF size

The pricing page says one credit covers each 5 MB chunk of generated output and credits reset on the first day of each month. Confirm how a PDF near a chunk boundary is counted and whether the displayed price suits your billing region and period.

PDFCrowd plans

Listed plan	Monthly price	Credits/month
Nano	$1	10
Micro	$11	200
Small	$23	1,000
Medium	$35	5,000
Large	$61	10,000
Ultimate	$106	20,000

PDFCrowd lists higher enterprise tiers too. The pricing page assigns tier-specific rate limits, concurrency, and maximum JavaScript-delay values; check the current tier details for the plan you are considering. The API trial lists 100 test credits valid for one month. The vendor says one credit covers 0.5 MB of output, credits reset on the billing date, and unused credits do not roll over.

How to estimate credit use

1. Collect a representative sample of the PDFs your application will generate, including the largest expected documents.
2. Measure each output size and estimate monthly totals, including retries and peak periods.
3. Apply each vendor’s stated size unit and chunk rules. At the stated rates, one HTML2PDF.app credit covers ten times as much output as one PDFCrowd credit. That ratio does not tell you which plan is cheaper, because plan prices and allotments differ.
4. Add concurrency and rate needs. A plan with enough monthly credits can still bottleneck when many jobs arrive together.
5. Recheck the exact plan terms at checkout. Listed prices may change and billing details can vary.

Do not compare 1,000 credits with 1,000 credits as if they represented the same volume. The vendors define a credit differently, and the HTML2PDF.app free plan also has a 1 MB output cap.

5. Runnable API examples

Keep API credentials out of source control and logs. Store them in environment variables or a secrets manager. The following examples show the basic request shapes; use current vendor documentation for the full set of rendering parameters.

HTML2PDF.app with cURL

curl --request POST \
  --url https://api.html2pdf.app/v1/generate \
  --header "X-API-Key: $HTML2PDF_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{"url":"https://example.com"}' \
  --output document.pdf

HTML2PDF.app with Python

import os
import requests

api_key = os.environ["HTML2PDF_API_KEY"]
response = requests.post(
    "https://api.html2pdf.app/v1/generate",
    headers={
        "X-API-Key": api_key,
        "Content-Type": "application/json",
    },
    json={"url": "https://example.com"},
    timeout=90,
)
response.raise_for_status()
with open("document.pdf", "wb") as pdf:
    pdf.write(response.content)

HTML2PDF.app with Node.js

const apiKey = process.env.HTML2PDF_API_KEY;
if (!apiKey) throw new Error("Set HTML2PDF_API_KEY first");

const response = await fetch("https://api.html2pdf.app/v1/generate", {
  method: "POST",
  headers: {
    "X-API-Key": apiKey,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ url: "https://example.com" }),
  signal: AbortSignal.timeout(90_000),
});
if (!response.ok) {
  throw new Error(`Conversion failed: HTTP ${response.status}`);
}
const bytes = new Uint8Array(await response.arrayBuffer());
await import("node:fs/promises").then(fs => fs.writeFile("document.pdf", bytes));

PDFCrowd with cURL

curl --user "$PDFCROWD_USERNAME:$PDFCROWD_API_KEY" \
  --request POST \
  --header "Content-Type: application/x-www-form-urlencoded" \
  --data-urlencode "url=https://example.com" \
  https://api.pdfcrowd.com/convert/24.04/ \
  --output document.pdf

PDFCrowd with Python

import os
import requests

response = requests.post(
    "https://api.pdfcrowd.com/convert/24.04/",
    auth=(os.environ["PDFCROWD_USERNAME"], os.environ["PDFCROWD_API_KEY"]),
    data={"url": "https://example.com"},
    timeout=75,
)
response.raise_for_status()
with open("document.pdf", "wb") as pdf:
    pdf.write(response.content)

PDFCrowd with Node.js

const username = process.env.PDFCROWD_USERNAME;
const apiKey = process.env.PDFCROWD_API_KEY;
if (!username || !apiKey) throw new Error("Set PDFCROWD_USERNAME and PDFCROWD_API_KEY");

const body = new URLSearchParams({ url: "https://example.com" });
const auth = Buffer.from(`${username}:${apiKey}`).toString("base64");
const response = await fetch("https://api.pdfcrowd.com/convert/24.04/", {
  method: "POST",
  headers: {
    Authorization: `Basic ${auth}`,
    "Content-Type": "application/x-www-form-urlencoded",
  },
  body,
  signal: AbortSignal.timeout(75_000),
});
if (!response.ok) {
  throw new Error(`Conversion failed: HTTP ${response.status}`);
}
const bytes = new Uint8Array(await response.arrayBuffer());
await import("node:fs/promises").then(fs => fs.writeFile("document.pdf", bytes));

For raw HTML rather than a URL, use the documented HTML input field for the service: PDFCrowd’s HTTP guide names the text field and also documents file/archive upload. Consult HTML2PDF.app’s current request schema for its raw-HTML field and any options you need. Do not send private HTML in a URL query string.

6. Selection workflow: test your real documents

1. Write down requirements. Record input form, output format, PDF/A or tagging needs, encryption, callback behavior, peak jobs, monthly volume, and data handling constraints.
2. Build a representative test set. Include a short page, a long report with page breaks, web fonts, charts or client-rendered content, protected resources if applicable, and the largest expected output.
3. Implement each request minimally. Start with the service’s documented request format and save the returned bytes. Then add only the rendering options needed for your output.
4. Inspect the PDFs. Check missing images and fonts, margins, page count, header/footer placement, links, selectable text, accessibility tags, and archival validation when those matter.
5. Record operational behavior. Measure latency and failure rate across repeated runs in your environment, check how the service reports errors, and verify concurrency/rate behavior against your expected bursts.
6. Calculate cost from output sizes. Apply each plan’s credit rule to observed sizes and include retries and peak traffic. Reconfirm prices and limits before committing.
7. Run a small production pilot. Keep a fallback or controlled rollback path until the output checks and operational needs are satisfied.

This process is a recommendation, not a claim that comparative tests have been run. Published specifications cannot predict rendering accuracy or reliability for a particular site.

7. Reliability, performance, and cost in production

Rendering performance

Conversion time depends on the page, scripts, remote assets, and readiness settings. Heavy client-side applications, slow fonts, and large images can extend work. Use readiness controls appropriate to the page and avoid waiting on unrelated network activity if your chosen API offers a more specific condition. The documentation reviewed does not provide comparable latency benchmarks, so measure your own representative jobs.

Concurrency and rate behavior

HTML2PDF.app lists one parallel conversion on Free and 3, 10, and 20 on its named paid plans. PDFCrowd says request rate and concurrency depend on license; its HTTP guide documents HTTP 429 for rate limiting and 430 for the concurrent request limit. Design a queue or bounded worker pool so a traffic spike does not turn into a burst of rejected calls. Confirm the precise limits on the active plan.

Retries and duplicate work

Retry transient network failures with bounded exponential backoff and jitter, but do not blindly retry permanent input or authentication errors. Preserve a job identifier in your own system so a caller retry does not accidentally create an uncontrolled duplicate conversion. For HTML2PDF.app’s callback flow, make callback processing idempotent and validate that the expected job is being completed. Confirm callback authentication and retry behavior in the current vendor docs before relying on it.

Output and storage

Stream or save returned bytes to controlled storage rather than logging binary response content. Check response status and content before treating a response as a PDF. PDFCrowd’s 300 MB figure is a maximum upload size; its separately documented 60-second server-side processing limit is not a maximum output size. HTML2PDF.app’s Free plan output cap is 1 MB, while paid plans list unlimited PDF size.

Cost controls

Set alerts before monthly credits are exhausted, track output size by document class, and review unusually large PDFs. If retries are possible, measure their impact rather than assuming each attempt is free. The pricing pages describe credit resets, but offer no basis here for estimating a workload’s actual monthly bill without its PDF size distribution.

8. Troubleshooting

Symptom	Likely cause	Fix
401 or 403 response	Missing, invalid, or incorrectly supplied credentials.	Check the HTML2PDF.app X-API-Key header or PDFCrowd Basic auth username/key pair. Ensure secrets are not accidentally whitespace-padded or using the wrong account.
400-class input error	Wrong request encoding, unsupported field, malformed URL, or invalid HTML input.	Match the endpoint’s documented schema: JSON for HTML2PDF.app’s documented request shape; form fields for PDFCrowd HTTP. Check current docs for exact input field names.
429 or PDFCrowd 430	Rate limit reached or concurrent request allowance exceeded.	Reduce worker concurrency, queue jobs, and check the license limits. Back off on 429 responses; do not immediately replay a whole batch.
Conversion exceeds client timeout	Slow remote resources, long scripts, or a timeout set too low.	Check page availability and asset loading, use suitable readiness settings, increase the client timeout within your request budget, and split or simplify oversized documents if possible. PDFCrowd documents a 60-second server-side processing limit.
Blank or incomplete PDF	Capture occurred before JavaScript rendered, or protected/remote assets were inaccessible.	Verify the input in an unauthenticated server context, configure documented readiness controls, and check asset URLs, cookies, and access restrictions.
Missing fonts, images, or styling	Resources are unavailable to the renderer, relative paths do not resolve, or CSS media differs.	Use reachable absolute assets or the documented upload/package route, verify font access and media settings, and inspect the page from the conversion environment where possible.
PDF rejected by expected output size	Plan cap or credit calculation misunderstood.	For HTML2PDF.app Free, account for the 1 MB output cap. Recalculate credit needs using the vendor’s output-size unit; PDFCrowd’s 300 MB limit concerns upload size, not output size.
Callback received twice or result processed twice	Asynchronous delivery may be retried, or your handler is not idempotent.	Make callback handling safe to repeat, persist completion state, and confirm the current callback delivery and verification details in HTML2PDF.app documentation.
PDF opens but layout differs from browser	Print CSS, viewport, media, fonts, and page breaks differ from the browser’s normal view.	Set the intended page and media options, add print-specific CSS where appropriate, and inspect representative outputs from both services before migration.

9. Where ScreenshotNeo fits

If the output you need is a screenshot rather than a PDF, try ScreenshotNeo first. It is a website screenshot API and MCP server from Yorker Media. Its one-call endpoint returns PNG, JPEG, WebP, or PDF. Cookie and consent banners are accepted as a visitor and more than 60 known consent platforms, newsletter popups, and chat widgets can be removed before capture, with each step configurable. Only clean shots are billed: bot checks/CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and responses identify the page verdict and billing status.

It also offers full-page and selector captures, device presets and custom viewports, dark mode, PDF options, custom CSS and JavaScript, waits, request blocking, cookies and headers, caching, signed image links, async jobs, bulk capture, and an MCP server with take_screenshot, get_page_info, and capture_pdf. See the ScreenshotNeo API documentation for parameters.

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}`);

ScreenshotNeo’s free plan includes 1,000 shots per month with no card; paid plans start at $5 for 3,000 shots. Every feature is on every plan. Its MCP server works with Claude, Cursor, and any MCP client. If your deliverable must be a document generated from HTML, compare the PDF services above; if a page capture meets the need, sign up for 1,000 free screenshots a month, with no card required.

10. FAQ

Are the two services using the same API format?

No. HTML2PDF.app documents a JSON POST with an API key header. PDFCrowd’s HTTP guide documents a versioned endpoint, Basic authentication, and form-encoded fields.

Which service is cheaper?

It depends on output sizes and plan needs. HTML2PDF.app assigns one credit per 5 MB chunk, while PDFCrowd assigns one credit per 0.5 MB. Calculate against real documents and current checkout terms.

Can I use PDFCrowd’s 300 MB limit as its maximum PDF size?

No. The cited HTTP guide identifies 300 MB as the maximum upload size. It separately states a 60-second server-side processing limit.

Which one renders more accurately?

The vendor pages reviewed do not establish that. Test the actual pages, fonts, assets, scripts, and layout requirements your application depends on.

Does either service provide a browser-based test tool?

Both vendors list online tools; HTML2PDF.app describes its no-key browser converter as interactive testing and directs automated or production use to the API. Check each current product page for access and limits.