Limits

The ones you are most likely to meet: your plan's conversions a month, upload size and conversions at once, 120 seconds per conversion, and 600 requests a minute per account.

Three limits depend on your plan: successful conversions a month, the size of a request, and conversions running at the same time. Every other limit on this page is the same for every key. Each value comes from the API's configuration or source code. A request that goes over a limit fails with an error; we don't hand back a partial result. The one exception is an HTML screenshot taller than 16,384 pixels, which is cut at that height (see the table below).

MB and GB on this page are binary units, as the code counts them: 1 MB is 1,048,576 bytes and 1 GB is 1,024 MB.

At a glance

Limit	Value	When you go over it
Successful conversions per calendar month (UTC)	Set by your plan (Plan limits)	On the Free plan, 429 `this month's 250 conversions on the Free plan are used up; the count starts again on 2026-12-01 (UTC)`. Paid plans keep converting.
Request size, all files and fields together	Set by your plan, 100 MB at most	413 `the Free plan accepts uploads up to 10 MB, all files together` on the Free plan, `uploads are limited to 100 MB` on paid plans
Conversions running at the same time	Set by your plan	429 `the Free plan runs 1 conversion at a time; wait for the one running to finish`
Files per request	50	400 `at most 50 files per request`
Parameters per request	100	400 `too many parameters`
Parameter name	Letters, digits and `_`, up to 64 characters	400 `parameter names must be letters, digits or _`
Parameter value	64 KB (65,536 bytes)	400 `parameter FileName is too long` (names the parameter)
Format name in the URL	Letters, digits and `-`, up to 20 characters	400 `invalid format in the URL`
Time per conversion	120 seconds	504 `the conversion timed out`
Wait for a free conversion slot	20 seconds	503 `the server is busy; retry shortly`
Requests per account (conversions and `GET /v2/usage`)	600 per 60 seconds	429 `too many requests; slow down`
Size of each output file	512 MB	413 `output file exceeds the size limit`
Image size, decoded	100,000,000 pixels	413 `the image is 10,001×10,001 pixels, above the limit of 100,000,000 pixels`
Image output, per side	16,384 pixels for WebP; 65,500 for JPEG; 65,535 for GIF and TGA	413 `WebP images can be at most 16,384 pixels on a side, and this one is 20,000×1,000; lower ImageWidth or ImageHeight`
Pages per request	2,000	413 that names the limit, such as `rendering is limited to 2,000 pages per request`
Stored file link	3 hours	404 `not found`

Plan limits

The Free plan allows 250 conversions a month, files up to 10 MB and 1 conversion at a time. Pricing lists the numbers for every plan. Billing isn't open yet, so the Free plan is the only one you can get yourself, by signing in at app.pdfconversionapi.com. For higher limits before billing opens, write to sales@pdfconversionapi.com.

GET /v2/usage returns your plan's limits and this month's count.

Conversions a month

The count runs for a calendar month in UTC. It starts again at 00:00 UTC on the first day of each month.
Only successful conversions count. A request that fails is not counted. One successful request is one conversion, however many pages or files it returns.
On the Free plan, conversions stop when the month's conversions are used up. Each conversion request then gets 429 this month's 250 conversions on the Free plan are used up; the count starts again on 2026-12-01 (UTC), with Retry-After set to the seconds until that date.
Paid plans don't stop: they keep converting past the conversions they include.

Upload size

Your plan sets the largest request it accepts, counting all files and fields together. Request size explains how it is checked. Over the limit, the Free plan answers 413 the Free plan accepts uploads up to 10 MB, all files together, and paid plans answer 413 uploads are limited to 100 MB.

Conversions at once

Your plan sets how many conversions your account runs at the same time. A conversion request that would go over gets 429 the Free plan runs 1 conversion at a time; wait for the one running to finish, with Retry-After: 5. Wait for a running conversion to finish, or send your requests one after another.

This is a limit per account. It is separate from the conversion slots on our servers: when every slot is busy, a request waits up to 20 seconds for one (Time).

Paused conversions

We have a switch that pauses conversions on the Free plan for a while, which we use against abuse. While it is on, conversion requests get 503 conversions on the Free plan are paused for a while; try again later, with Retry-After: 600.

Request size

Your plan sets the largest request, counting every file and field in the multipart body. No plan takes more than 100 MB (104,857,600 bytes), and the Free plan takes less (Plan limits). We check the Content-Length header, so an oversized request is refused before its body is read. A body sent without Content-Length is counted as it streams and refused once it passes the limit.

Our cloud provider's network, which sits in front of the API, also limits request size. A request close to 100 MB can be refused there, before it reaches us, with an HTML 413 page instead of our JSON error. Errors shows how to handle both.

Two more sizes matter on the hosted API:

25 MB: our gateway keeps requests up to this size in memory, so it can send one again when a container is busy. A bigger request streams through once; if its container is busy, you get the 503 directly.
HTML that needs a browser: we lay out HTML without a browser unless the page runs scripts, isn't UTF-8, is larger than 10 MB, or comes with one of a few options such as WaitElement. Those pages need a headless browser, which runs in a separate container pool. The gateway has to resend those requests there, so they must fit in 25 MB. A larger one gets 413 this page needs the browser engine and is too large to resend. In practice, HTML to PDF, PNG or JPG takes requests up to 25 MB, or up to your plan's limit if that is lower.

To convert more data than fits, split the input and send several requests: for example, a few images per images/to/pdf request, then pdf/to/merge on the results.

Files and parameters

Requests explains how files and parameters are sent. The limits on them:

50 files per request. Every file counts: File, each Files entry and named file fields such as ImageFile.
100 parameters per request. Every field other than File and Files counts, named file fields included.
Parameter names: letters, digits and _, up to 64 characters. Names are case-insensitive.
Parameter values: up to 65,536 bytes each.
Format names in the URL: letters, digits and -, up to 20 characters, case-insensitive.
Output names: the name part is cut at 120 characters (Responses).

Time

Every conversion is one synchronous request: you send the file and wait for the result in the same HTTP response. There are no background jobs or webhooks yet.

120 seconds per conversion. Engines that run as separate programs, such as the office suite and the browser, are stopped at 120 seconds together with every helper process they started. The request gets 504 the conversion timed out.
20 seconds of waiting for a slot. Each container runs a fixed number of conversions at once. A request that can't get a slot within 20 seconds gets 503 the server is busy; retry shortly, after the gateway has resent it up to two more times (requests up to 25 MB only).
170 seconds per request in a container. A container gives up on any request it hasn't answered after 170 seconds: the 120 above, the 20-second wait, and 30 seconds of margin. That 504 has an empty body (Errors).

Give your HTTP client a timeout of at least 240 seconds, as our Python examples and the retry examples do. That leaves room for the conversion, the waits above and your own upload and download. With a shorter timeout your client can give up on a conversion that is still running, and the conversion keeps its slot on our side until it ends.

If a file regularly takes close to 120 seconds, split it (for example with PageRange, where the conversion supports it, or with pdf/to/split first) or lower the resolution of page images.

Request rate

Each account can send 600 requests per 60 seconds, counting conversion requests and GET /v2/usage together. The limit is per account, not per key (Authentication).

It counts every POST /v2/convert/... and GET /v2/usage that has a valid key, including conversion requests that then fail with a 400, 404, 413 or 422.
Downloads of stored files, DELETE /v2/d/{id}, GET /v2/info and GET /health don't count.
Over the limit, you get 429 too many requests; slow down with Retry-After: 10. Errors has retry code that honors it.

The count is kept by our cloud provider's rate limiter, which is approximate and counts separately in each of the provider's locations. A burst can pass 600 before the first 429, and requests that reach us through different locations are counted apart. Plan for 600 per minute; don't rely on the exact point where 429s start.

The rate limit is separate from your plan's conversions at once and conversions a month. All three answer 429. The message says which one you reached, and Retry-After says how long to wait.

Output, pages and pixels

These limits depend on what the file contains, so they apply after the upload has been read. Each one answers 413 with a message that names it, except where the table says otherwise.

What	Limit	Notes
Each output file	512 MB	Checked for every file in `Files`.
Any image we decode, and any page we render to an image	100,000,000 pixels	10,000 × 10,000 pixels is allowed; 10,001 × 10,001 is not. The size is read from the image's header and checked before the image is decoded. It is checked again on the size `ImageWidth` and `ImageHeight` ask for: a 2,000 × 1,000 PNG sent to PNG to JPG with `ImageWidth=20000` gets `the image is 20,000×10,000 pixels, above the limit of 100,000,000 pixels; lower ImageWidth or ImageHeight`.
XCF images	67,108,864 pixels on the canvas, and 300,000 pixels per side	Lower than the limit above. The canvas size is read from the file's header. Answers 413 `XCF images can be at most 67,108,864 pixels, and this one's canvas is larger`, or for a canvas of 300,001 × 100 pixels `XCF images can be at most 300,000 pixels on a side, and this one is 300,001×100`.
A page rendered to an image (PDF and documents to JPG, PNG, WebP or TIFF)	16,000 pixels per side	Depends on `ImageResolution` (36 to 600 DPI, default 150), or on `ImageWidth` and `ImageHeight` when you send them. The message names the page and the size it would have. In our test file, page 3 is 2,000 by 1,000 points, and at 600 DPI it gets `page 3 is too large to draw at 16,666×8,333 pixels; lower ImageResolution`. When `ImageWidth` or `ImageHeight` set the size, the message ends with `; lower ImageWidth or ImageHeight` instead: `ImageWidth=17000` on a Letter page gets `page 1 is too large to draw at 17,000×22,000 pixels; lower ImageWidth or ImageHeight`. `pdf/to/rasterize` has the same limit and names its own option: a 2,000-point square page at `Resolution=600` gets `page 1 is too large to draw at 16,666×16,666 pixels; lower Resolution`.
An image written as WebP, JPEG, GIF or TGA	16,384 pixels per side for WebP; 65,500 for JPEG; 65,535 for GIF and TGA	The limits of the formats themselves, and for JPEG the largest side that common JPEG decoders read. They are checked on the size the image will have after `ImageWidth` and `ImageHeight`. The message names the format and the size: a PNG of 70,000 × 10 pixels sent to PNG to JPG gets `JPEG images can be at most 65,500 pixels on a side, and this one is 70,000×10`. It ends with `; lower ImageWidth or ImageHeight` only when you sent one of them and the conversion applies it.
Pages per request	2,000	Applies to page images, PDF to SVG, the total pages of a merge, the parts of a split, DICOM frames, and HTML, emails and e-books laid out to PDF. The message names the case: a 2,001-page PDF gets `rendering is limited to 2,000 pages per request` on PDF to JPG, `conversion is limited to 2,000 pages per request` on PDF to SVG, and `splitting would create more than 2,000 files` on `pdf/to/split`.
HTML to PNG or JPG	16,384 pixels per side	A longer page is cut at that height (or sooner, at 100,000,000 pixels in all), not refused.
Raster image to SVG	12,000,000 pixels	Send `ImageWidth` or `ImageHeight` to scale the image down first. A 4,000 × 3,001 WebP gets `vectorizing is limited to 12,000,000 pixels, and this image is 4,000×3,001; set ImageWidth or ImageHeight to scale it down`. When the size you sent is still too large, the message ends with `; lower ImageWidth or ImageHeight` instead.
`zip/to/extract`	10,000 files, 1 GB unpacked	The unpacked size is counted as it is read, not taken from the archive's own claims. An archive with more entries gets `the archive has more than 10,000 entries`.
Attachments from `pdf/to/extract-attachments`	10,000 files, 1 GB in total
One compressed stream inside a PDF	256 MB when decompressed	Checked where our own PDF code reads the file, for example in merge, split and PDF to images. A PDF past this answers 422: the file can't be read.
EPUB and MOBI books, MHTML pages	64 MB of HTML after unpacking	For books: `the book is too large to lay out`.
CSV to XLSX	1,048,576 rows, 16,384 columns	Excel's own sheet size. Answers 413 `the CSV has more than 1,048,576 rows`, or `row 1 has more than 16,384 columns` for the first row that is too wide.
QR code data (`data/to/qrcode`)	1 to 2,953 bytes	Answers 400 `QR data must be 1–2953 bytes`.