HEIF to TIFF API
POST a .heif to /v2/convert/heif/to/tiff and get a single-page, uncompressed TIFF with four 8-bit samples per pixel, the fourth holding the HEIF's alpha plane. The sample asks for 150 dpi; the 320 × 320 sticker needs 409,814 bytes.
- Endpoint
- POST /v2/
convert/ heif/ to/ tiff - Accepts
- heif
- Sample timing
- 23 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/heif/to/tiff \
-H "Authorization: Bearer $PDFCONVERSIONAPI_KEY" \
-F File=@succulent-sticker.heif \
--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/heif/to/tiff",
headers={"Authorization": f"Bearer {key}"},
files=[("File", open("succulent-sticker.heif", "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 = "succulent-sticker.heif";
form.append("File", new Blob([await readFile(file)]), file);
form.append("ImageResolution", "150");
const url = "https://api.pdfconversionapi.com/v2/convert/heif/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.023,
"Files": [
{
"FileName": "succulent-sticker.tiff",
"FileExt": "tiff",
"FileSize": 409814,
"FileData": "SUkqAChABgCWAAAAAQAAAJYA…"
}
]
}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
- succulent-sticker.heif (11 KB)
- Output
- succulent-sticker.tiff (400 KB)
- Source
- A potted succulent sticker that we drew ourselves, with a transparent background and a soft shadow, saved as a 320 x 320 HEIF with an alpha plane. (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 | Writes the resolution tags in inches; the sample reports 150 dpi. Without it they read 1, with no unit.Values: 10–800 |
ImageWidthinteger | Scales color and alpha; 200 gave 160,214 bytes.Values: 1–20000 |
ImageHeightinteger | Target height, or a box with ImageWidth.Values: 1–20000 |
ScaleProportionsboolean, default true | false stretches to both sizes. |
ScaleIfLargerboolean, default false | true never enlarges. |
ScaleImageboolean, default true | false crops the top-left area. |
ColorSpaceenum, default default | rgb leaves the sample as it is. On an image with transparency, gray and monochrome keep four samples per pixel: red, green and blue become equal (only 0 and 255 with monochrome) and the alpha plane stays, in 409,814 bytes.Values: default, rgb, gray, monochrome |
TransparentColorstring | Clears pixels of exactly this color in the alpha channel too; #C4623B removed 5,931 pot pixels.Values: #RRGGBB, R,G,B or a basic color name |
FileNamestring | Base name of the .tiff. |
StoreFileboolean, default false | true returns a 3-hour download link. |
What carries over, and what doesn't
Kept
- Every RGBA value: identical to the HEIF to PNG output, partial alpha included
- The 150 dpi the sample asks for, in inches
- Transparency as read by both readers we tried
Lost or not yet supported
- An explicit alpha label: the file has four samples per pixel but no
ExtraSamplestag saying the fourth is alpha. Both readers we tried treated it as alpha anyway. - Compression: the TIFF stores rows raw, 409,814 bytes for an 11,269-byte HEIF.
- A one-channel file for transparent images:
grayandmonochromestill write four samples per pixel, so the size doesn't drop. - Tones of HEIF files with an embedded Display P3 profile.
Limits
- One HEIF per request, one page per TIFF.
- Up to 100,000,000 decoded pixels; requests up to 10 MB on the Free plan or 100 MB on paid plans; 120 seconds per conversion.
- AV1-coded HEIF (AVIF) returns 422.
Where teams use it
Cut-outs for print and layout
Layout and prepress software places TIFF graphics with transparency over other page content. A HEIF sticker from a phone or tablet converts with its clear background and a stated resolution.
Archiving graphics with their mask
Uncompressed TIFF needs no codec to read later, and the alpha plane is stored next to the color rather than flattened away.
Questions
What does `ColorSpace=gray` give for a transparent image?
An RGBA TIFF whose red, green and blue values are equal, with the alpha plane kept: the sample's 72,482 clear pixels and the soft shadow come through, in 409,814 bytes. An opaque HEIF gets a true one-channel gray TIFF instead; our 400 × 300 harbor sent as .heif gave 120,198 bytes.
Will layout programs see the transparency?
Both readers we tried read the fourth sample as alpha. Because the ExtraSamples tag is missing, a strict program could treat it as an unspecified extra channel; test with your software.
How large will the TIFF be?
Width × height × 4 bytes plus about 200 bytes of tags: 409,814 for the 320 × 320 sample. There is no compression option, and ImageQuality is accepted and ignored.
Convert your first HEIF file in a minute.