WebP to TIFF API
POST a WebP to /v2/convert/webp/to/tiff and get an uncompressed 8-bit TIFF with the decoded pixels, as RGBA when the WebP has transparency. ImageResolution writes a DPI, as the sample does with 300.
- Endpoint
- POST /v2/
convert/ webp/ to/ tiff - Accepts
- webp
- Sample timing
- 3 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/webp/to/tiff \
-H "Authorization: Bearer $PDFCONVERSIONAPI_KEY" \
-F File=@guest-badge.webp \
--form-string ImageResolution=300 \
-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/webp/to/tiff",
headers={"Authorization": f"Bearer {key}"},
files=[("File", open("guest-badge.webp", "rb"))],
data={
"ImageResolution": "300",
},
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 = "guest-badge.webp";
form.append("File", new Blob([await readFile(file)]), file);
form.append("ImageResolution", "300");
const url = "https://api.pdfconversionapi.com/v2/convert/webp/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.003,
"Files": [
{
"FileName": "guest-badge.tiff",
"FileExt": "tiff",
"FileSize": 416214,
"FileData": "SUkqAChZBgAsAQAAAQAAACwB…"
}
]
}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
- guest-badge.webp (9.4 KB)
- Output
- guest-badge.tiff (406 KB)
- Source
- A guest pass for a made-up trade show that we drew for this page, saved as a lossy WebP with a transparent background and a soft shadow. (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 | Written into the TIFF's resolution tags in inches. The sample sends 300; without it the tags say 1 × 1 with no unit.Values: 10–800 |
ImageWidthinteger | Target width; 200 gave a 200 × 130 TIFF of 104,214 bytes.Values: 1–20000 |
ImageHeightinteger | Target height, or the box height when sent with ImageWidth.Values: 1–20000 |
ScaleProportionsboolean, default true | false resizes to fill the exact box. |
ScaleIfLargerboolean, default false | true keeps the WebP's size when it already fits. |
ScaleImageboolean, default true | false cuts out the top-left part instead of resizing. |
TransparentColorstring | Makes one exact color transparent as well; #FFFFFF added 42,768 clear pixels.Values: Color name, #RRGGBB or R,G,B |
ColorSpaceenum, default default | gray and monochrome work on WebPs with alpha too: the badge stayed RGBA, with equal red, green and blue values and its alpha intact, at 416,214 bytes; monochrome holds only black and white. rgb is accepted, and cmyk returns 400.Values: default, rgb, gray, monochrome |
MultiPageboolean, default true | Accepted either way; a WebP gives one page. |
ImageInterpolationboolean, default false | Accepted; resizing always uses Lanczos. |
FileNamestring | Name for the TIFF; guest-badge.tiff by default. |
StoreFileboolean, default false | true returns Files[].Url, valid for 3 hours, instead of 416 KB of base64. |
Not supported yet
Setting one of these to anything but its default returns 400.
| Option | What to do instead |
|---|---|
ImageQuality | 75 is accepted; any other value returns 400 'ImageQuality is not supported yet for WebP → TIFF'. The TIFF is always uncompressed. |
What carries over, and what doesn't
Kept
- Every decoded pixel and alpha value: the sample TIFF equals the reference WebP decode exactly.
- Transparency, including the soft shadow, as a fourth 8-bit channel.
- The DPI you send: the sample's tags read 300 pixels per inch.
- EXIF orientation, applied to the pixels: a 300 × 200 WebP tagged 6 became an upright 200 × 300 TIFF.
Lost or not yet supported
- Compression: 9,596 bytes became 416,214, as the TIFF is written uncompressed.
- A labeled alpha channel. The fourth channel has no ExtraSamples tag, so strict TIFF tools print a warning; three readers we tried still treated it as transparency.
- Frames after the first of an animated WebP.
- ICC profiles, EXIF and XMP; a Display P3 WebP came back with no profile.
Limits
- One WebP per request.
- Requests up to 10 MB on the Free plan or 100 MB on paid plans, all files and fields together.
- Images over 100,000,000 pixels return 413.
- 120 seconds per conversion before a 504.
Where teams use it
Web images into print and prepress
Print shops and layout tools may want TIFF with a stated resolution. Convert a WebP from a client's website and set ImageResolution so it places at the intended size.
Archive copies in a long-lived format
Store a TIFF next to the WebP for systems that only ingest TIFF. Every decoded pixel and alpha value is kept, uncompressed.
Questions
Is the TIFF compressed?
No. It is written uncompressed, and ImageQuality can't change that. The 400 × 260 badge is 416,214 bytes: 4 bytes per pixel plus the header.
Does the TIFF keep transparency?
Yes, as a fourth channel with the original alpha values. The file lacks the ExtraSamples tag that labels that channel, which some strict tools warn about, but the readers we tried kept it transparent.
How do I set 300 dpi?
Send ImageResolution=300, as the sample does. A WebP has no DPI of its own, so without it the TIFF's resolution tags read 1 × 1 with no unit.
Can I get a grayscale TIFF?
Yes. With ColorSpace=gray the badge came back as gray values in an RGBA TIFF of 416,214 bytes, so the transparency stays. An opaque WebP gets a true one-channel gray TIFF: our 400 × 260 test file gave 104,198 bytes.
Convert your first WebP file in a minute.