How to Test the PDFCrowd API with Postman

To test PDFCrowd’s PDF-to-HTML API in Postman, send a POST request to https://api.pdfcrowd.com/convert/24.04/, authenticate with Basic Auth using your PDFCrowd username and API key, and send input_format=pdf and output_format=html as form-data. Add either a reachable PDF URL in url or a local PDF in file. A successful response is 200 OK and contains HTML or ZIP bytes; inspect the status and Content-Type before interpreting the body.

Build the request in Postman

Create a new request, set the method to POST, and enter https://api.pdfcrowd.com/convert/24.04/. Keep the versioned endpoint explicit. PDFCrowd documents this endpoint in its HTTP guide and API reference.
Open Authorization, choose Basic Auth, and enter your PDFCrowd username as the username and your API key as the password. For a shared collection, store credentials in secure Postman variables or Vault rather than saving real values directly in the request.
Open Body and select form-data. Add the following text fields:

Key	Type	Value
`input_format`	Text	`pdf`
`output_format`	Text	`html`

Choose exactly one PDF input route:

URL: Add a text field named url, with an http:// or https:// address that returns a PDF and can be reached from PDFCrowd’s servers.
Local file: Add a field named file, change its type from Text to File, and select the PDF from your computer.

Do not send a JSON body. PDFCrowd expects form fields; Postman’s form-data mode supports text fields and file uploads and sets the appropriate content type. For a file upload, let Postman generate the multipart boundary. Don’t set a manual Content-Type: multipart/form-data header, because a manually supplied header can omit the boundary Postman needs.

Send and read the response

Click Send, then check the HTTP status before treating the body as converted output. For a successful conversion, PDFCrowd documents 200 OK. Inspect the response headers and body:

What to check	What it tells you
Status	Whether the request succeeded. Don’t assume an error body is converted content.
`Content-Type`	`text/html` indicates HTML; `application/zip` indicates ZIP output.
Response body	HTML or ZIP bytes. If the body is ZIP, save it as a file and open it with an archive tool.
`x-pdfcrowd-debug-log`	When present, provides a diagnostics link for the conversion.

With default resource handling, images, stylesheets, and fonts are embedded. Resource-separation options or force_zip=true can make the response a ZIP instead. For a first test, leave these options at their defaults. If you change resource settings, use the PDFCrowd API reference to confirm the relevant parameter names and expected output.

Use the same request outside Postman

These examples use the same endpoint, Basic Auth credentials, and form fields. Replace the placeholders with your own credentials and use either the URL or file input shown.

cURL with a PDF URL

curl -u 'PDFCROWD_USERNAME:PDFCROWD_API_KEY' \
  -F input_format=pdf \
  -F output_format=html \
  -F 'url=https://example.com/document.pdf' \
  'https://api.pdfcrowd.com/convert/24.04/' \
  -o converted.html

cURL with a local file

curl -u 'PDFCROWD_USERNAME:PDFCROWD_API_KEY' \
  -F input_format=pdf \
  -F output_format=html \
  -F 'file=@./document.pdf' \
  'https://api.pdfcrowd.com/convert/24.04/' \
  -o converted.html

When using resource-separation options or force_zip=true, choose an output filename such as converted.zip and inspect the returned content type.

Python with requests

import requests

endpoint = "https://api.pdfcrowd.com/convert/24.04/"
auth = ("PDFCROWD_USERNAME", "PDFCROWD_API_KEY")
data = {"input_format": "pdf", "output_format": "html"}

# Choose one input route: URL or local file.
data["url"] = "https://example.com/document.pdf"
# For a local file, remove the url line and use:
# files = {"file": open("document.pdf", "rb")}
files = None

response = requests.post(endpoint, auth=auth, data=data, files=files, timeout=120)
print(response.status_code, response.headers.get("Content-Type"))
response.raise_for_status()
with open("converted.html", "wb") as output:
    output.write(response.content)

For the local-file variant, uncomment the files assignment and remove the URL assignment. Close the file after the request in production code, for example by opening it in a with block around requests.post. If the response is ZIP, save it with a .zip extension instead.

Node.js with fetch

const endpoint = 'https://api.pdfcrowd.com/convert/24.04/';
const username = 'PDFCROWD_USERNAME';
const apiKey = 'PDFCROWD_API_KEY';
const form = new FormData();
form.append('input_format', 'pdf');
form.append('output_format', 'html');
form.append('url', 'https://example.com/document.pdf');

const auth = Buffer.from(`${username}:${apiKey}`).toString('base64');
const response = await fetch(endpoint, {
  method: 'POST',
  headers: { Authorization: `Basic ${auth}` },
  body: form,
});
const bytes = Buffer.from(await response.arrayBuffer());
console.log(response.status, response.headers.get('content-type'));
if (!response.ok) {
  console.error(bytes.toString('utf8'));
  throw new Error(`PDFCrowd returned HTTP ${response.status}`);
}
await import('node:fs/promises').then(({ writeFile }) =>
  writeFile('converted.html', bytes)
);

For a local upload in Node.js, append a file object supported by your runtime’s FormData implementation as the file field. Don’t set the multipart content-type header yourself; the runtime must add its boundary. The example reads the response as bytes so it can also save ZIP output without corrupting it.

Options and input edge cases

URL versus upload: URL input is convenient when the PDF is already reachable by PDFCrowd, but it can fail when the URL requires a private network, browser session, or login. Uploading file sends a local document with the multipart request and avoids remote URL reachability as an input dependency.
Input and output formats: Set both input_format=pdf and output_format=html for this conversion. Use the exact field names and values.
Resources and archives: Defaults embed resources; options that separate resources, and force_zip=true, can return ZIP. Decide how the client will save and unpack the output before enabling those options.
Error formatting: Add ?errfmt=json to the endpoint when JSON-formatted error responses are easier to process. It affects errors; a successful result remains HTML or ZIP.
PDF validity: The input needs to be an actual readable PDF. A URL that returns an HTML login page or an error page is not a usable PDF even if the server responds successfully.

Troubleshooting

Symptom	Likely cause	What to do
Request reports missing input or request data	Body is not form-data, a field name is misspelled, or neither `url` nor `file` is included.	Select form-data, check the exact keys, and supply one PDF input.
Authentication failure	Wrong credential, reversed username/API key, or Basic Auth was not selected.	Set Basic Auth username to the PDFCrowd username and password to the API key. Check secure variables for empty or stale values.
URL cannot be loaded	The URL is private, redirects to a login page, does not return a PDF, or is unreachable from PDFCrowd’s servers.	Check the URL response and access requirements; try uploading the PDF with `file`.
PDF cannot be opened	The input is corrupt, incomplete, mislabeled, or not actually a PDF.	Open the file locally and verify it is a valid PDF, then retry with a known-good document.
File upload fails or is malformed	A manually configured multipart header may have omitted the boundary, or the field remains Text.	Set the `file` row type to File and let Postman generate the multipart header.
Response appears unreadable	The body is ZIP bytes, or an error body is being mistaken for HTML.	Check status and `Content-Type`. Save ZIP output as an archive; for errors, try `?errfmt=json`.
Need more conversion detail	The status/body alone does not explain a conversion failure.	Look for the `x-pdfcrowd-debug-log` response header; PDFCrowd also provides logs in conversion history.

Performance, reliability, and cost considerations

Conversion time and response size depend on the input document and whether resources are embedded or returned separately. For large files or slower conversions, avoid overly short client timeouts and handle network failures explicitly. Keep the original PDF so you can retry a failed request. Treat retries carefully: a client timeout does not prove the service did not receive the request, so review conversion history if duplicate work matters.

The research sources do not establish a conversion speed, success rate, or API price, so this guide makes no benchmark or cost claim. Check your PDFCrowd account and current plan terms for charges and usage limits. In Postman, inspect the full response and diagnostics before concluding whether a failure is an authentication, input, or conversion issue.

Or skip the browser setup

PDFCrowd converts PDFs to HTML; ScreenshotNeo captures website pages as images or PDFs. If what you need is a screenshot of a web page, ScreenshotNeo can do that with one GET request. See the API documentation for options and response details.

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 removes cookie banners, popups, and chat widgets before the shot; bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card, and paid plans start at $5 for 3,000.

FAQ

Can I send JSON from Postman?

No. PDFCrowd’s HTTP API expects form fields; use form-data for text values and file uploads.

Should I use the URL or file field?

Use url when the PDF is reachable by PDFCrowd’s servers. Use file when you have the document locally or the remote URL cannot be reached.

Why did I get a ZIP instead of HTML?

Resource-separation settings or force_zip=true can cause ZIP output. Check Content-Type and save the response as an archive.

Does ScreenshotNeo convert a PDF to HTML?

No. ScreenshotNeo captures web pages as screenshots or PDFs. Use PDFCrowd for the PDF-to-HTML conversion described in this guide.