PPSX to WebP API
POST /v2/convert/ppsx/to/webp gives back a lossless WebP per slide the show plays. With no options our museum loop came back as five 1,999 × 1,125 images, from 34,288 bytes for the chart slide to 85,874 for the navy welcome slide.
- Endpoint
- POST /v2/
convert/ ppsx/ to/ webp - Accepts
- ppsx
- Sample timing
- 0.714 s 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/ppsx/to/webp \
-H "Authorization: Bearer $PDFCONVERSIONAPI_KEY" \
-F File=@pilot-house-welcome.ppsx \
-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/ppsx/to/webp",
headers={"Authorization": f"Bearer {key}"},
files=[("File", open("pilot-house-welcome.ppsx", "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 = "pilot-house-welcome.ppsx";
form.append("File", new Blob([await readFile(file)]), file);
const url = "https://api.pdfconversionapi.com/v2/convert/ppsx/to/webp";
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.714,
"Files": [
{
"FileName": "pilot-house-welcome-1.webp",
"FileExt": "webp",
"FileSize": 85874,
"FileData": "UklGRmpPAQBXRUJQVlA4TF5P…"
},
{
"FileName": "pilot-house-welcome-2.webp",
"FileExt": "webp",
"FileSize": 81394,
"FileData": "UklGRuo9AQBXRUJQVlA4TN09…"
},
{
"FileName": "pilot-house-welcome-3.webp",
"FileExt": "webp",
"FileSize": 34288,
"FileData": "UklGRuiFAABXRUJQVlA4TNuF…"
},
… 2 more files
]
}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
- pilot-house-welcome.ppsx (46 KB)
- Output
- pilot-house-welcome-1.webp (84 KB)pilot-house-welcome-2.webp (79 KB)pilot-house-welcome-3.webp (33 KB)pilot-house-welcome-4.webp (44 KB)pilot-house-welcome-5.webp (41 KB)
- Source
- A six-slide welcome loop for a fictional harbor museum, set to advance by itself, with one hidden staff slide. We made it for this page. (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, default 150 | Pixels per inch of slide: 1,999 × 1,125 by default, 959 × 540 at 72, where the chart slide is 15,722 bytes. WebP has no DPI field, so only the pixel size changes.Values: 36–600 |
ImageWidthinteger | Exact width with the height in proportion, for example 1280 for 1,280 × 720.Values: 1–20,000 |
ImageHeightinteger | Exact height with the width in proportion.Values: 1–20,000 |
PageRangestring | Slides to convert, numbered after hidden slides are removed, for example 1 for the welcome slide only.Values: e.g. 1, 2-4 |
ConvertHiddenSlidesboolean, default false | Include hidden slides; the sample then gives 6 files with the staff checklist fourth. |
TransparentColorstring | Makes one exact color transparent: white on the lamp-room slide at 36 DPI cleared 90,635 of its 129,330 pixels. |
Passwordstring | Opens a password-protected show; without it the answer is 422. |
FileNamestring | Base of the names, which end in the page number: -1.webp to -5.webp for the sample. |
StoreFileboolean, default false | Get a link per image instead of base64 data; links last 3 hours. |
Not supported yet
Setting one of these to anything but its default returns 400.
| Option | What to do instead |
|---|---|
ImageQuality | The images are lossless, so there is no quality to choose. Values other than 75 (ConvertAPI's default) return 400 "ImageQuality is not supported yet for PPSX → WebP". |
ConvertSpeakerNotes | Notes are not drawn; anything but Disabled returns 400. |
What carries over, and what doesn't
Kept
- Every pixel of the render: the WebP of slide 1 decodes to exactly the same pixels as the PNG
- No alpha channel in the files until you set
TransparentColor, which adds one - The navy and sand full-bleed backgrounds and the red holiday-hours line
- The order of the show, in the file names
Lost or not yet supported
- Lossy compression. Without a quality setting, a show full of photos stays larger than a lossy WebP would be.
- The DPI: WebP has nowhere to store it.
- Calibri letter shapes (the text is drawn in Carlito at the same widths), the speaker note and the hidden slide.
- The fade and the 8-second advance between slides.
Limits
- Up to 2,000 images per request.
- 16,000 pixels per side, 100 million per image.
- 10 MB on the Free plan or 100 MB on paid plans per request, 120 seconds per conversion.
Where teams use it
A slide gallery on the venue's website
Publish every slide of the lobby loop as images on the visitor page. The five lossless WebP files total 289,358 bytes, against 613,601 for the same slides as PNG.
Previews in a content system
Store one WebP per slide next to each uploaded .ppsx, so editors can check what the screen will show before the file goes out to the players.
Questions
Why is ImageQuality refused?
Our WebP output is always lossless, so a quality number would change nothing. Instead of ignoring it, the API answers 400 for any value but 75, ConvertAPI's default. Use JPEG if you want lossy files.
How do the sizes compare with PNG and JPEG?
For the five slides at 1,999 × 1,125: 289,358 bytes as WebP, 613,601 as PNG, and 708,536 as JPEG at our default quality of 85. The WebP and PNG files hold the same pixels.
Which slides do I get?
The five the show plays. Slide 4 of the file is hidden from the screen, so it is left out until you send ConvertHiddenSlides=true.
Convert your first PPSX file in a minute.