PAGES to TIFF API
POST /v2/convert/pages/to/tiff draws each page of a Pages document as its own uncompressed TIFF. The sample requests page 1 in grayscale at 100 DPI and gets one 583 × 826 pixel file of 481,756 bytes that records 100 DPI.
- Endpoint
- POST /v2/
convert/ pages/ to/ tiff - Accepts
- pages
- Sample timing
- 0.55 s median of 5 runsHow we measure
- Request size
- Up to 10 MB on the Free plan or 100 MB on paid plans, all files together
Request and response
Every sample below ran against the API before this page was published. Set PDFCONVERSIONAPI_KEY to your key and run it as is.
curl -sS -X POST \
https://api.pdfconversionapi.com/v2/convert/pages/to/tiff \
-H "Authorization: Bearer $PDFCONVERSIONAPI_KEY" \
-F File=@garden-rules.pages \
--form-string PageRange=1 \
--form-string ColorSpace=gray \
--form-string ImageResolution=100 \
-o response.json
# FileData is base64. Save the first file in converted/,
# or print the JSON error.
if jq -e '.Files' response.json > /dev/null; then
mkdir -p converted
name=$(jq -r '.Files[0].FileName' response.json)
jq -r '.Files[0].FileData' response.json \
| base64 --decode > "converted/$name"
else
cat response.json
fiimport base64
import os
import requests
key = os.environ["PDFCONVERSIONAPI_KEY"]
response = requests.post(
"https://api.pdfconversionapi.com/v2/convert/pages/to/tiff",
headers={"Authorization": f"Bearer {key}"},
files=[("File", open("garden-rules.pages", "rb"))],
data={
"PageRange": "1",
"ColorSpace": "gray",
"ImageResolution": "100",
},
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 = "garden-rules.pages";
form.append("File", new Blob([await readFile(file)]), file);
form.append("PageRange", "1");
form.append("ColorSpace", "gray");
form.append("ImageResolution", "100");
const url = "https://api.pdfconversionapi.com/v2/convert/pages/to/tiff";
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.55,
"Files": [
{
"FileName": "garden-rules-1.tiff",
"FileExt": "tiff",
"FileSize": 481756,
"FileData": "SUkqAC5ZBwBkAAAAAQAAAGQA…"
}
]
}Response from our test run on 2026-11-03. ConversionTime shows the median of 5 runs. FileData is shortened here; the real response carries the whole file as base64.
The sample, converted
The same file the code sends. Download the input and the output and compare them yourself.

- Input
- garden-rules.pages (44 KB)
- Output
- garden-rules-1.tiff (470 KB)
- Source
- A two-page A5 Apple Pages document with garden rules we wrote; we put our text into a Pages test file from an open-source office suite's test data (MPL-2.0). How it was made
- Made by
- 2026-11-04, API build
9eeeb0640aba
Parameters
Send these as form fields next to the file. Names are case-insensitive. If you set one of the documented options below that we don't support yet, the request fails with a 400 that names it instead of returning a file made without it.
| Parameter | What it does |
|---|---|
ImageResolutioninteger, default 150 | Resolution of the drawn page, stored in the TIFF. An A5 page is 875 × 1,239 pixels at 150 and 583 × 826 at the sample's 100.Values: 36 to 600 |
ColorSpaceenum, default default | gray keeps one byte per pixel instead of three; monochrome reduces pixels to black and white but stores them the same way.Values: default, rgb, gray, monochrome |
PageRangestring | Pages to return as TIFFs; the sample keeps only page 1.Values: Page numbers and ranges |
MultiPageboolean, default false | true puts all pages in one LZW-compressed TIFF, garden-rules.tiff: 199,909 bytes for the two A5 pages at 150 DPI, where each separate page is 3,252,617 bytes. With ColorSpace=gray and 100 DPI both pages stay one-channel gray in an 80,877-byte file. |
FileNamestring | Stem of the page files: garden-rules-1.tiff and so on. |
StoreFileboolean, default false | Return 3-hour download links instead of the TIFF data. |
What carries over, and what doesn't
Kept
- The A5 page shape and margins: 583 × 826 pixels at 100 DPI
- The DPI you request, recorded in the TIFF
- Every pixel: single pages are stored raw, and the multi-page file uses lossless LZW
Lost or not yet supported
- Compact files, when pages come back one by one: at the default 150 DPI in color, each A5 page is 3,252,617 bytes.
- Bullets in lists, and Helvetica (drawn as Liberation Sans).
Limits
- Page setup options such as
PageSizereturn 400 "... is not supported yet for PAGES files". - Up to 2,000 pages, 16,000 pixels per side and 100 million pixels per page (413 above that).
- Requests up to 10 MB on the Free plan or 100 MB on paid plans, all files and fields together. A conversion can run for up to 120 seconds; after that the API returns 504.
Where teams use it
Filing Pages documents in an imaging system
Records systems built around scanned paper store pages as TIFF. Converting a .pages letter puts it in the same form as the scans next to it.
Page images for print shops
Some print and sign workflows take TIFF artwork. Each A5 page comes out at the resolution you ask for, with that DPI written into the file.
Questions
How do I get a single multi-page TIFF?
Send MultiPage=true. For the sample that gives one 2-page TIFF of 199,909 bytes with LZW compression, where the default is two separate files of 3,252,617 bytes each. Going through /v2/convert/pages/to/pdf and then /v2/convert/pdf/to/tiff gave the same file byte for byte.
Why are the files so big?
This route doesn't compress TIFF pages. Lower ImageResolution, use ColorSpace=gray, or send MultiPage=true, which compresses.
Does a black-and-white TIFF get smaller?
No. ColorSpace=monochrome stores 8 bits per pixel like gray, so the file is the same size; only the pixel values change.
Convert your first PAGES file in a minute.