PDF conversion API for developers

How it works

One HTTP call per conversion

mkdir -p converted
curl -sS https://api.pdfconversionapi.com/v2/convert/docx/to/pdf \
  -H "Authorization: Bearer $PDFCONVERSIONAPI_KEY" \
  -F File=@quarterly-report.docx \
  --form-string UpdateFields=true \
  | jq -r '.Files[0].FileData // error(.Message)' \
  | base64 --decode > converted/quarterly-report.pdf

import base64
import os

import requests

key = os.environ["PDFCONVERSIONAPI_KEY"]
response = requests.post(
    "https://api.pdfconversionapi.com/v2/convert/docx/to/pdf",
    headers={"Authorization": f"Bearer {key}"},
    files=[("File", open("quarterly-report.docx", "rb"))],
    data={
        "UpdateFields": "true",
    },
    timeout=180,
)
result = response.json()
if not response.ok:
    raise SystemExit(f"{result['Code']}: {result['Message']}")

os.makedirs("converted", exist_ok=True)
for file in result["Files"]:
    path = os.path.join("converted", file["FileName"])
    with open(path, "wb") as out:
        out.write(base64.b64decode(file["FileData"]))
    print(path, file["FileSize"], "bytes")

import { mkdir, readFile, writeFile } from "node:fs/promises";
import { join } from "node:path";

const form = new FormData();
const file = "quarterly-report.docx";
form.append("File", new Blob([await readFile(file)]), file);
form.append("UpdateFields", "true");

const url = "https://api.pdfconversionapi.com/v2/convert/docx/to/pdf";
const key = process.env.PDFCONVERSIONAPI_KEY;
const response = await fetch(url, {
  method: "POST",
  headers: { Authorization: `Bearer ${key}` },
  body: form,
});
const result = await response.json();
if (!response.ok) {
  throw new Error(`${result.Code}: ${result.Message}`);
}

await mkdir("converted", { recursive: true });
for (const file of result.Files) {
  const path = join("converted", file.FileName);
  await writeFile(path, Buffer.from(file.FileData, "base64"));
  console.log(path, file.FileSize, "bytes");
}

{
  "ConversionCost": 1,
  "ConversionTime": 0.046,
  "Files": [
    {
      "FileName": "quarterly-report.pdf",
      "FileExt": "pdf",
      "FileSize": 82830,
      "FileData": "JVBERi0xLjcKJYCAgIAKMSAw…"
    }
  ]
}

Conversions, one request shape

556

Input formats, from DOCX to DWG and HEIC

71

Median for our DOCX to PDF sample, 5 runs. How we measure

46 ms

Per request, all files together (10 MB on the Free plan)

100 MB

1. 1Your app

   Sends the file over HTTPS with your key in the Authorization header.

2. 2API gateway

   Checks the key and your rate limit, then picks the container pool for the conversion.

3. 3Conversion container

   Converts the file in memory or in a temporary folder, with internet access turned off, and deletes what it wrote.

4. 4Response

   Carries the converted file back. Nothing is kept unless you set StoreFile=true.

• Nothing is kept by default

  Each conversion runs in a temporary folder that is deleted when it ends, and the result comes back in the response.

• Stored results expire

  With StoreFile=true, the download link works for 3 hours. A cleanup job runs every 15 minutes and deletes expired files, and only your account can delete a file early.

• No internet inside the converters

  The containers that run conversions start with internet access turned off, so a document can't call out or load remote content.

• Isolated per conversion

  Conversions run as a non-root user, in separate container pools by kind of conversion. An engine still running after 120 seconds is stopped.

• Encrypted in transit and at rest

  Requests travel over HTTPS. Stored results are encrypted with AES-256. Files aren't end-to-end encrypted: the converter has to read them.

• Keys are hashed

  We store only the SHA-256 hash of each API key, and accept keys only in the Authorization header, never in the URL.

• Stored results stay in the US

  Files you ask us to keep are stored in the US. Conversions themselves run wherever a container is free.

• Not used for training

  We don't use your files to train or improve any model.

• Limits that protect the service

  A request can carry up to 10 MB on the Free plan or 100 MB on paid plans, a result up to 512 MB or 2,000 pages, and each key is rate-limited.