WebP to PDF
Convert WebP images into a single PDF document that opens in any reader. Metadata is stripped automatically. Files are processed in your browser — they never leave your device.
WebP to PDF converts WebP images — Google's modern web image format, frequently encountered when you save images from websites — into a single PDF document that opens in any reader. The tool runs entirely in your browser using pdf-lib via a Web Worker. Drop up to 30 WebPs (25 MB each), reorder them, pick A4 / Letter / Fit-to-image, then click Create PDF. EXIF and ICC chunks are stripped automatically.
What is WebP to PDF?
WebP to PDF takes one or more WebP images — usually those you saved from a web page (Google Images, Pinterest, news sites) where browsers now serve WebP by default — and packs them into a single PDF document. Each WebP becomes one page (or several per page if you enable that), sized to A4, US Letter, or fitted exactly to the image. The output is a standard PDF that opens in every reader, even those that don't know what WebP is.
WebP is a great web format but a poor delivery format outside the browser — many email clients, office suites, and older PDF tools don't support it. Converting WebP to PDF gives you a portable file that works everywhere. Most online services that do this upload your WebP files to a remote server. This tool runs the whole conversion in your browser, so the images never cross the network.
How does the in-browser conversion work?
Pikowl loads each WebP into a Web Worker — a background thread inside your browser. The worker decodes each file using createImageBitmap (which natively understands WebP in modern browsers), draws it onto an OffscreenCanvas, then re-encodes it as JPEG at quality 0.92. The format conversion is necessary because pdf-lib doesn't natively embed WebP — but the canvas re-encode also drops EXIF and ICC chunks, which is the privacy win. The finished PDF is offered as a downloadable Blob via URL.createObjectURL. Nothing is sent to any server.
Is it safe to convert sensitive WebP images here?
Yes. Open the network tab in DevTools while you use the tool — you will see no outbound requests during the conversion. WebP files are read locally via the File API, processed in a sandboxed Web Worker, and the resulting PDF lives only in your browser's memory until you download it. Closing the tab discards everything.
What metadata gets stripped from WebPs?
WebP files can carry RIFF chunks like EXIF (re-using the JPEG EXIF format), ICCP (color profile), and XMP (Adobe metadata). When a website serves a WebP that originated as a JPEG photo, the EXIF chunk often retains the original GPS coordinates, camera info, and timestamps. Because Pikowl decodes the WebP and re-encodes it as JPEG via canvas, all RIFF chunks are dropped — only the pixel data survives in the output. The PDF you download contains no metadata from the source WebP.
What are the limits and why?
Up to 30 WebPs per conversion, 25 MB per file, with a soft warning at 100 MB combined and a hard cap at 150 MB. WebP files tend to be small (that's the format's selling point — typically 25-35% smaller than JPEG for the same quality), so you'll rarely hit the per-file limit, but decoded bitmaps are full-size RGBA in memory regardless of how compact the source is. A 5 MB WebP at 4K resolution still decodes to ~33 MB of working memory. Mobile Safari can crash above ~200 MB. For larger batches, convert in passes and combine with Merge PDF.
How does Pikowl compare to Smallpdf and iLovePDF for WebP-to-PDF?
The substantive differences are processing location, EXIF handling, daily-use limits, and pricing. Numbers below reflect the public free-tier offers from each service as of April 2026.
| Feature | Pikowl | Smallpdf | iLovePDF |
|---|---|---|---|
| Where files are processed | Your browser | Remote server | Remote server |
| Sign-up required | No | Optional | Optional |
| EXIF / GPS handling | Stripped automatically | Preserved | Preserved |
| Max file size (free) | 25 MB | 5 MB | 200 MB (combined) |
| Price | Free | $9/mo for unlimited | $7/mo for premium |
Sources: smallpdf.com/pricing and ilovepdf.com/pricing, retrieved April 2026.
Common Uses
- Saved web images: WebPs downloaded from Google Images, Pinterest, or news sites usually need to be converted before you can attach them to an email or insert them in a Word doc.
- Modern stock photography: Many stock-photo sites now deliver WebP previews; convert them to PDF for a portable proof or moodboard.
- App screenshots from web tooling: Browser-based screenshot tools (Chrome's built-in capture, GoFullPage, etc.) often save as WebP — bundle them into one PDF for documentation.
- Product catalogs: E-commerce sites that serve WebP product imagery — combine a set into a printable PDF catalog without re-fetching as JPG.
- Blog post archives: When archiving a blog post locally, the inline WebP images need a portable container; PDF is the standard.
- Cross-platform sharing: Some older devices and email clients still don't render WebP; converting to PDF guarantees everyone can open it.
FAQ
Are my WebPs uploaded to a server?
No. The conversion runs entirely in your browser — open DevTools' network tab and you'll see no outbound requests during the process. WebP files are read from your disk via the File API, decoded and re-encoded in a Web Worker, embedded into a PDF using pdf-lib, and offered back as a download. Nothing leaves your device.
Why does WebP get re-encoded as JPEG inside the PDF?
pdf-lib, the underlying open-source PDF library, supports embedding only JPEG and PNG image streams — not WebP. So this tool decodes each WebP and re-encodes it to JPEG at quality 0.92 before embedding. The visual difference is negligible for photographic content; the file-size difference depends on how aggressively the source WebP was compressed. As a side benefit, the JPEG re-encode strips all EXIF and ICC metadata.
Does this remove EXIF / GPS data?
Yes — automatically. WebP files can carry EXIF chunks (often inherited when the WebP was generated from a JPEG photo) that include GPS coordinates, camera details, and timestamps. The decode + canvas re-encode pipeline drops all RIFF chunks (EXIF, ICCP, XMP), so the resulting PDF carries no metadata from the source. Smallpdf and iLovePDF typically preserve this metadata.
Does WebP transparency survive in the PDF?
No. Because we re-encode each WebP to JPEG (since pdf-lib doesn't embed WebP natively), and JPEG has no alpha channel, transparent WebP pixels become white in the PDF. If you need transparency preserved, save your image as PNG first and use the PNG-to-PDF tool, which uses a lossless PNG path with full alpha support.
Why is this tool WebP-only? I have a mix of formats.
Each format gets its own tool so the conversion path is right for that format: WebP → JPEG re-encode (pdf-lib limitation), PNG → lossless PNG embed, JPG → JPEG re-encode. For a mixed batch, convert each format with the right tool and combine the resulting PDFs using our Merge PDF tool.
Can I choose the page size?
Yes. Pick A4 (210×297 mm — global standard), US Letter (8.5×11 in — North America), or "Fit to image" which sizes each PDF page to the image's exact pixel dimensions. Use Fit when you want a borderless image-as-document; use A4 or Letter when the PDF needs to print on standard paper.
How is the order of images set?
Use the drag handle (the dotted icon on the left of each row) to drag a WebP up or down. On mobile, press and hold the handle, then drag. The PDF will arrange pages in exactly the order shown in the list, top-down. Filenames are kept in the on-screen list but are not embedded in the PDF.
By the Numbers
- WebP, developed by Google and announced in 2010, became a W3C-recommended web format and now powers a substantial share of images served on Google, Facebook, and major news sites.
- WebP files are typically 25-35% smaller than equivalent JPEGs at the same visual quality — which is why browsers prefer to download them, but also why so many people end up with WebPs they need to convert (Google Developers, WebP overview).
- OffscreenCanvas + createImageBitmap are supported in 97% of browsers globally (Can I Use, 2026), giving us a reliable off-main-thread path to decode WebP without freezing the UI.