ORA to TIFF API
With POST /v2/convert/ora/to/tiff, the visible OpenRaster layers are composited into a single TIFF page with no compression. The sample sends ImageResolution=150 so the TIFF carries the same 150 dpi that its stack.xml declares.
- Endpoint
- POST /v2/
convert/ ora/ to/ tiff - Accepts
- ora
- Sample timing
- 44 ms 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/ora/to/tiff \
-H "Authorization: Bearer $PDFCONVERSIONAPI_KEY" \
-F File=@garden-plan.ora \
--form-string ImageResolution=150 \
-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/ora/to/tiff",
headers={"Authorization": f"Bearer {key}"},
files=[("File", open("garden-plan.ora", "rb"))],
data={
"ImageResolution": "150",
},
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-plan.ora";
form.append("File", new Blob([await readFile(file)]), file);
form.append("ImageResolution", "150");
const url = "https://api.pdfconversionapi.com/v2/convert/ora/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.044,
"Files": [
{
"FileName": "garden-plan.tiff",
"FileExt": "tiff",
"FileSize": 360210,
"FileData": "SUkqAGR+BQCWAAAAAQAAAJYA…"
}
]
}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-plan.ora (123 KB)
- Output
- garden-plan.tiff (352 KB)
- Source
- A backyard vegetable garden plan that we drew and saved as an OpenRaster file with seven layers and a layer group, including a hidden layer and a multiply layer. (CC0-1.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 | Resolution tags in dots per inch. The xres and yres in the .ora are not read, so without this the TIFF says 1/1 with no unit.Values: 10–800 |
ImageWidthinteger | Pixel width; 160 gives a 160 × 120 TIFF of 57,810 bytes and 800 one of 1,440,226.Values: 1–20000 |
ImageHeightinteger | Pixel height; the 4:3 plan becomes 200 × 150 at 150.Values: 1–20000 |
ScaleProportionsboolean, default true | false with a 200 × 200 box squares the plan off (120,210 bytes). |
ScaleIfLargerboolean, default false | true refuses any enlargement. |
ScaleImageboolean, default true | false crops the box from the top-left corner (32,610 bytes for 120 × 90). |
ColorSpaceenum, default default | On this opaque plan, gray and monochrome each give a one-sample 8-bit TIFF of 120,198 bytes, a third of the RGB size. On a canvas with transparency they keep four samples, with equal R, G and B next to the alpha.Values: default, rgb, gray, monochrome (also srgb, truecolors, grayscale); cmyk returns 400 |
TransparentColorstring | Adds an alpha channel and clears one exact color; the TIFF grows to 480,214 bytes with 13 white pixels transparent.Values: #RRGGBB, R,G,B or a color name |
FileNamestring | Base name of the .tiff; garden-plan otherwise. |
StoreFileboolean, default false | Store for 3 hours and reply with a link. |
What carries over, and what doesn't
Kept
- The exact composite: the TIFF's pixels equal our PNG output for the same .ora
- RGB without alpha for an opaque canvas like the sample (3 samples per pixel); alpha is added when the canvas has transparent areas
- 16 bits per sample when the layers are 16-bit PNGs
- The DPI you pass: the sample's tags read 150 per inch
Lost or not yet supported
- Compression: 360,210 bytes for 400 × 300, against 66,293 for the PNG.
- Layers and groups, merged into one page.
- The resolution written in stack.xml, unless you repeat it in
ImageResolution. - Color profiles embedded in layer PNGs, which are ignored.
Limits
- One .ora per request, canvas up to 100,000,000 pixels, with each side at most 300,000 px.
- Requests up to 10 MB on the Free plan or 100 MB on paid plans, all files and fields together.
- 120 seconds per conversion, then 504.
- Single-page, uncompressed TIFF only.
Where teams use it
Printing a plan at a known size
Send ImageResolution and the TIFF states it, so software that reads the DPI places the 400 × 300 plan at 2.67 by 2 inches when you pass 150.
Archival copies of layered drawings
Keep an uncompressed, flat TIFF next to the .ora. It decodes to exactly the composite our PNG route returns, and stays readable without a painting app.
Questions
Does the TIFF use the resolution stored in the .ora?
No. stack.xml says 150 dpi for the sample, but the TIFF only carries a resolution when you send ImageResolution. With 150, the tags read 150 per inch and the unit is inches.
Can I get a grayscale TIFF?
Yes, for opaque drawings: ColorSpace=gray wrote an 8-bit gray TIFF of 120,198 bytes. If the canvas has transparent areas, the TIFF stays RGBA: the gray value fills R, G and B and the alpha is kept, so the file is as large as the color one.
Are 16-bit OpenRaster layers kept at 16 bits?
Yes. A test .ora with a 16-bit layer PNG produced a TIFF with 16 bits per sample and the original values, for example 4369 out of 65535.
Convert your first ORA file in a minute.