SVG to TIFF API
POST an SVG to /v2/convert/svg/to/tiff to receive a single-page RGBA TIFF. ImageResolution=300 in the sample writes 300 DPI into the tags without changing the 300 × 300 pixel size; ImageWidth is what adds pixels.
- Endpoint
- POST /v2/
convert/ svg/ to/ tiff - Accepts
- svg
- Sample timing
- 11 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/svg/to/tiff \
-H "Authorization: Bearer $PDFCONVERSIONAPI_KEY" \
-F File=@water-day-icon.svg \
--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/svg/to/tiff",
headers={"Authorization": f"Bearer {key}"},
files=[("File", open("water-day-icon.svg", "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 = "water-day-icon.svg";
form.append("File", new Blob([await readFile(file)]), file);
form.append("ImageResolution", "300");
const url = "https://api.pdfconversionapi.com/v2/convert/svg/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.011,
"Files": [
{
"FileName": "water-day-icon.tiff",
"FileExt": "tiff",
"FileSize": 360214,
"FileData": "SUkqAGh+BQAsAQAAAQAAACwB…"
}
]
}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
- water-day-icon.svg (2.1 KB)
- Output
- water-day-icon.tiff (352 KB)
- Source
- An app icon for a fictional plant-watering reminder, with two gradients, a soft drop shadow and a text label, which we drew by hand. (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 | DPI written to XResolution and YResolution with inches as the unit. It sets how large the image prints, not how many pixels it has. Without it the tags say 1 with no unit.Values: 10–800 |
ImageWidthinteger | Pixel width of the render. To print the icon 2 inches wide at 300 DPI, send ImageWidth=600 with ImageResolution=300.Values: 1–20000 |
ImageHeightinteger | Pixel height of the render.Values: 1–20000 |
ScaleProportionsboolean, default true | false fills both sizes exactly. |
ScaleIfLargerboolean, default false | true never makes the render larger than the SVG's own size. |
ScaleImageboolean, default true | false crops from the top left instead of scaling. |
TransparentColorstring | Clears pixels of exactly this color: #FFFFFF added 695 transparent pixels to the sample.Values: Color names (white, black, red, green, blue, gray), #RRGGBB or R,G,B |
ColorSpaceenum, default default | gray and monochrome on a drawing with transparent pixels, like the sample, give an RGBA page holding gray values, alpha kept (360,214 bytes at 300 px). On an SVG with an opaque background, gray gave an 8-bit gray TIFF. rgb drops an alpha channel that no pixel uses: that opaque SVG came back as 3-channel RGB, 270,210 bytes instead of 360,214. cmyk returns 400.Values: default, rgb, gray, monochrome |
MultiPageboolean, default true | Accepted, but an SVG always gives one page. |
FileNamestring | Name of the TIFF without extension. |
StoreFileboolean, default false | Returns a URL to the file, kept 3 hours. |
Not supported yet
Setting one of these to anything but its default returns 400.
| Option | What to do instead |
|---|---|
ImageQuality | The TIFF is lossless. 75, ConvertAPI's default, is accepted; other values return 400 "ImageQuality is not supported yet for SVG → TIFF". |
What carries over, and what doesn't
Kept
- Every pixel and alpha value: the sample decodes to exactly the PNG render
- The DPI you send, as 300/1 with ResolutionUnit inch
- The soft shadow's partial transparency
- Crisp edges at the pixel size you ask for
Lost or not yet supported
- Compression: the page is stored raw, 360,214 bytes for 300 × 300 where the PNG is 26,512.
- A one-channel gray file for drawings with transparency: they stay RGBA, with equal red, green and blue (see
ColorSpace). - CMYK: output is RGB only.
- A label for the fourth channel: there is no ExtraSamples tag, though the three readers we tried all treated it as alpha.
- Text in fonts we don't have and images not embedded in the SVG.
Limits
- One SVG per request, one page per TIFF.
- Requests up to 10 MB on the Free plan or 100 MB on paid plans, all files and fields together.
- Renders above 100,000,000 pixels return 413.
ImageWidthandImageHeight1 to 20,000;ImageResolution10 to 800.- 120 seconds per conversion, then 504.
Where teams use it
Print layouts that need a size in inches
Pair ImageWidth with ImageResolution so the TIFF carries both the pixels and the physical size the layout should use: 600 px at 300 DPI is a 2-inch icon.
Systems that store TIFF only
Archive and document systems that accept TIFF can take vector logos and diagrams once they are rendered, with alpha kept for later compositing.
Questions
Does ImageResolution give me more pixels?
No. The SVG's own size (or ImageWidth) sets the pixels; ImageResolution only fills in the resolution tags. Multiply the print size in inches by the DPI to get the width to send.
Why is the TIFF so large?
The page is written without compression: 4 bytes per pixel, 360,214 bytes for the 300 × 300 sample and 1,440,230 bytes at 600 × 600. If size matters, PNG or WebP keep the same pixels in a fraction of that.
Can I get a grayscale TIFF?
Yes. With the sample's clear corners, ColorSpace=gray keeps four channels: gray values in red, green and blue, and the alpha as it was. A drawing without transparent pixels gets a true 8-bit gray TIFF: with a full-size white rectangle behind the icon, it was 90,198 bytes.
Is the TIFF multi-page?
No, an SVG is one page. MultiPage is accepted and has nothing to combine.
Convert your first SVG file in a minute.