ORA to BMP API
POST an .ora to /v2/convert/ora/to/bmp and get the composite of its visible layers as an uncompressed BMP. An opaque canvas, as in the sample, gives 24 bits per pixel behind a 40-byte header; transparent areas switch the file to 32 bits with an alpha byte.
- Endpoint
- POST /v2/
convert/ ora/ to/ bmp - Accepts
- ora
- Sample timing
- 45 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/bmp \
-H "Authorization: Bearer $PDFCONVERSIONAPI_KEY" \
-F File=@garden-plan.ora \
-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/bmp",
headers={"Authorization": f"Bearer {key}"},
files=[("File", open("garden-plan.ora", "rb"))],
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);
const url = "https://api.pdfconversionapi.com/v2/convert/ora/to/bmp";
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.045,
"Files": [
{
"FileName": "garden-plan.bmp",
"FileExt": "bmp",
"FileSize": 360054,
"FileData": "Qk12fgUAAAAAADYAAAAoAAAA…"
}
]
}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.bmp (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 |
|---|---|
ImageWidthinteger | Bitmap width. At 3 bytes a pixel, a 160 × 120 version is 57,654 bytes and an 800 × 600 one 1,440,054.Values: 1–20000 |
ImageHeightinteger | Bitmap height; 150 gives 200 × 150 (90,054 bytes).Values: 1–20000 |
ScaleProportionsboolean, default true | false lets a 200 × 200 request distort the plan to a square. |
ScaleIfLargerboolean, default false | true keeps the 400 × 300 size when you ask for larger. |
ScaleImageboolean, default true | false takes a top-left crop (32,454 bytes for 120 × 90). |
ColorSpaceenum, default default | Gray and monochrome change the values but keep 24 bits per pixel, so the size stays 360,054 bytes.Values: default, rgb, gray, monochrome (also srgb, truecolors, grayscale); cmyk returns 400 |
ImageResolutioninteger | Pixels per meter in the header: 150 stores 5,906. The .ora's own 150 ppi is not carried over without it.Values: 10–800 |
FileNamestring | Returned name, garden-plan.bmp unless set. |
StoreFileboolean, default false | A 3-hour link instead of about 480 KB of base64. |
What carries over, and what doesn't
Kept
- Exact composite pixels: the BMP decodes to our PNG output of the same .ora
- Alpha when the canvas has it: a 32 × 32 test .ora with transparent areas gave a 32-bit BMP with a 108-byte BITMAPV4 header
- The 400 × 300 canvas, bottom-up row order as BMP readers expect
Lost or not yet supported
- Compression: 360,054 bytes, more than five times the 66,293-byte PNG.
- The layer stack and the hidden layer, which is not drawn.
- The 150 ppi, unless you pass
ImageResolution. - 16-bit depth from 16-bit layer PNGs; BMP gets 8 bits per channel.
Limits
- One .ora per call, canvas up to 100,000,000 pixels; stack.xml sizes over 300,000 px a side return 422.
- Requests up to 10 MB on the Free plan or 100 MB on paid plans, all files and fields together.
- 120-second conversion limit, then 504.
- The depth follows the canvas, 24-bit when opaque and 32-bit with transparency; no 8-bit, paletted or RLE BMP option.
Where teams use it
Programs that read only BMP
When a Windows utility, a kiosk display or a plotter driver accepts BMP and nothing else, convert the OpenRaster file directly rather than exporting from a painting app.
Simple pixel access in code
BMP's fixed header and plain pixel rows are easy to parse without a library, which helps in small firmware or teaching projects that start from layered drawings.
Questions
Does an opaque drawing get an alpha channel?
No. When every pixel is opaque, as in the plan, the BMP is 24-bit: blue, green and red per pixel, no masks. If any pixel is transparent, the writer switches to 32 bits with red, green, blue and alpha masks, so the transparency is kept.
How large will the BMP be?
For opaque art, 54 bytes of headers plus 3 bytes per pixel, each row padded to a multiple of 4 bytes. The 400 × 300 plan is 360,054 bytes; a 160 px wide copy is 57,654, and 161 px wide gives 58,618 because of the padding. Use StoreFile=true for big canvases so the response carries a link rather than the data.
Are blend modes from the .ora applied?
Yes, before the BMP is written. The sample's Multiply layer at 50% darkens the title band, and the group with the beds and plants is merged as one unit.
Convert your first ORA file in a minute.