How to Convert Images to WebP (Free Methods for Every Platform)

WebP is the modern image format that should be your default for web content in 2026. Developed by Google, it delivers 25-35% smaller file sizes than JPEG at equivalent visual quality, supports transparency (like PNG), and supports animation (like GIF) — all in a single format with 97%+ browser support.

If you're still serving JPEG and PNG images on your website, converting to WebP is the single easiest performance win you can make. This guide covers every method to convert your images, from quick one-off conversions to automated batch processing.

Why Convert to WebP?

File Size Savings

Real-world compression comparisons at visually equivalent quality:

Original Format	Original Size	WebP Size	Savings
JPEG (q85)	284 KB	196 KB	31%
JPEG (q90)	412 KB	268 KB	35%
PNG (screenshot)	485 KB	342 KB (lossless)	29%
PNG (graphic)	156 KB	98 KB (lossless)	37%
GIF (animation)	2.4 MB	864 KB	64%

Performance Impact

• Faster page loads: Smaller images download faster, especially on mobile networks
• Better Core Web Vitals: Smaller LCP images improve your Largest Contentful Paint score
• Reduced bandwidth: For high-traffic sites, the savings translate directly to lower hosting costs
• Better user experience: Images appear faster, reducing bounce rates

Browser Support

WebP is supported by over 97% of browsers worldwide as of 2026:

• Chrome 23+ (2012)
• Firefox 65+ (2019)
• Edge 18+ (2018)
• Safari 14+ (2020)
• Opera 12.1+ (2012)
• All modern mobile browsers (iOS Safari 14+, Chrome Android, Samsung Internet)

The only browsers without WebP support are Internet Explorer (discontinued) and very old Safari versions. For these edge cases, you can serve JPEG/PNG fallbacks using the <picture> element.

Method 1: Free Online Converter (Quickest)

For individual images or small batches, a browser-based converter is the fastest method.

Using ImgLink Image Converter

1. Go to the ImgLink Image Converter
2. Drop your image(s) onto the converter area or click to browse
3. Select "WebP" as the output format
4. Adjust quality if desired (80 is the sweet spot for most images)
5. Click Convert and download the result

Key advantage: The conversion happens entirely in your browser. Your images are never uploaded to a server — they're processed locally using JavaScript. This means instant conversion, no file size limits imposed by a server, and complete privacy.

After converting, you can upload the WebP images directly to ImgLink for permanent hosting with direct links and CDN delivery.

Method 2: Squoosh (Google's Tool)

Squoosh (squoosh.app) is Google's open-source image compression web app. It's excellent for comparing formats side-by-side:

1. Open squoosh.app in your browser
2. Drop an image onto the page
3. Select "WebP" as the output format on the right panel
4. Drag the quality slider to compare the original vs. converted version
5. Download when satisfied with the quality/size balance

Squoosh is great for understanding how different quality levels affect your specific images, but it only handles one image at a time.

Method 3: Desktop Apps

XnConvert (Free, Cross-Platform)

XnConvert is a free batch image converter for Windows, Mac, and Linux. It's ideal for converting hundreds of images at once:

1. Download XnConvert from xnview.com
2. Drag your images (or entire folders) into the Input tab
3. In the Output tab, select "WebP" as the format
4. Set quality to 80
5. Click "Convert" — it processes all images in parallel

GIMP (Free, Cross-Platform)

GIMP supports WebP export natively since version 2.10:

1. Open your image in GIMP
2. File → Export As
3. Change the file extension to .webp
4. In the export dialog, set quality to 80 and click Export

Photoshop (Paid)

Adobe Photoshop has supported WebP natively since version 23.2 (February 2022):

1. Open your image
2. File → Save a Copy (or Export → Export As)
3. Select WebP format
4. Set quality and click Save

Method 4: Command Line (cwebp)

Google provides a dedicated command-line tool called cwebp that's part of the libwebp package. It offers the most control and is ideal for automation.

Installation

# macOS (Homebrew)
brew install webp

# Ubuntu/Debian
sudo apt install webp

# Windows (Chocolatey)
choco install webp

# Or download binaries directly from:
# https://developers.google.com/speed/webp/download

Basic Conversion

# Convert a single JPEG to WebP at quality 80
cwebp -q 80 input.jpg -o output.webp

# Convert PNG to lossless WebP
cwebp -lossless input.png -o output.webp

# Convert with specific size target (50 KB)
cwebp -size 50000 input.jpg -o output.webp

Batch Conversion

# Bash: Convert all JPEGs in a directory
for f in *.jpg; do
  cwebp -q 80 "$f" -o "${f%.jpg}.webp"
done

# Including subdirectories
find . -name "*.jpg" -exec sh -c 'cwebp -q 80 "$1" -o "${1%.jpg}.webp"' _ {} \;

# PowerShell
Get-ChildItem -Filter "*.jpg" | ForEach-Object {
  cwebp -q 80 $_.FullName -o ($_.FullName -replace '\.jpg$', '.webp')
}

Advanced Options

# Resize during conversion (max 1200px wide, maintain aspect ratio)
cwebp -q 80 -resize 1200 0 input.jpg -o output.webp

# Use the "sharp-yuv" option for better color accuracy
cwebp -q 80 -sharp_yuv input.jpg -o output.webp

# Multi-threaded conversion with metadata stripping
cwebp -q 80 -mt -metadata none input.jpg -o output.webp

Method 5: Node.js with Sharp

For developers integrating WebP conversion into a build pipeline or application, Sharp is the fastest Node.js image processing library:

import sharp from 'sharp';
import { glob } from 'glob';

// Single image conversion
await sharp('input.jpg')
  .webp({ quality: 80 })
  .toFile('output.webp');

// Batch conversion with resize
const files = await glob('images/*.{jpg,png}');
for (const file of files) {
  await sharp(file)
    .resize(1200, null, { withoutEnlargement: true })
    .webp({ quality: 80 })
    .toFile(file.replace(/\.(jpg|png)$/i, '.webp'));
  
  console.log(`Converted: ${file}`);
}

Integration with Build Tools

For websites using build tools, convert images at build time:

// Webpack: use image-minimizer-webpack-plugin
// Vite: use vite-plugin-image-optimizer
// Next.js: built-in Image component handles WebP automatically
// Astro: @astrojs/image handles format conversion

Method 6: Python with Pillow

from PIL import Image
import os

def convert_to_webp(input_path, quality=80):
    img = Image.open(input_path)
    output_path = os.path.splitext(input_path)[0] + '.webp'
    img.save(output_path, 'webp', quality=quality)
    
    original_size = os.path.getsize(input_path)
    webp_size = os.path.getsize(output_path)
    savings = (1 - webp_size / original_size) * 100
    
    print(f"{input_path}: {original_size//1024}KB -> {webp_size//1024}KB ({savings:.0f}% smaller)")

# Convert all images in a directory
for f in os.listdir('images'):
    if f.lower().endswith(('.jpg', '.jpeg', '.png')):
        convert_to_webp(os.path.join('images', f))

Serving WebP with Fallbacks

For the ~3% of browsers that don't support WebP, serve fallbacks using the HTML <picture> element:

<picture>
  <source srcset="image.webp" type="image/webp">
  <img src="image.jpg" alt="Description" width="800" height="600" loading="lazy">
</picture>

The browser automatically selects the first <source> it supports. WebP-capable browsers load the WebP; others fall back to the JPEG.

Server-Side Content Negotiation

Alternatively, your server can check the Accept header and serve the right format automatically:

# Nginx: Serve WebP when the browser supports it
map $http_accept $webp_suffix {
    default "";
    "~*webp" ".webp";
}

location ~* \.(jpg|png)$ {
    try_files $uri$webp_suffix $uri =404;
}

This approach serves WebP to supporting browsers without any HTML changes — ideal for existing sites with thousands of image references.

Quality Settings Guide

The "quality" parameter controls the compression/quality tradeoff. Here's what different levels look like in practice:

Quality	File Size (vs q100)	Visual Quality	Best For
100	100%	Maximum (often identical to lossless)	Archival, master files
90	~60%	Excellent — no visible artifacts	Photography portfolios
80	~40%	Very good — imperceptible to most viewers	General web use (recommended)
70	~30%	Good — slight softening on close inspection	Thumbnails, social media
60	~22%	Acceptable — artifacts visible on zoom	Low-bandwidth optimization
50	~18%	Noticeable artifacts	Preview images only

Recommendation: Quality 80 is the sweet spot for web images. It delivers excellent visual quality at roughly 40% of the maximum file size. For photographs where quality is paramount, use 85-90. For thumbnails and UI elements, 70-75 is sufficient.

Common Conversion Mistakes

• Converting from already-compressed JPEG again: Each lossy-to-lossy conversion introduces quality loss. Always convert from the highest-quality source available (ideally lossless PNG/TIFF masters).
• Using quality 100 for web: WebP at quality 100 is nearly identical to lossless but much larger than q80-85. You get no visible benefit but significant size penalty.
• Forgetting transparency: When converting PNG with transparency to WebP, ensure you use a WebP mode that preserves alpha. Most tools handle this automatically, but check your results.
• Not testing results: Always spot-check converted images, especially at quality levels below 75. Different image content responds differently to compression.
• Ignoring animated GIFs: An animated GIF-to-WebP conversion can save 50-70% file size — don't skip these.

After Conversion: Hosting WebP Images

Once your images are converted to WebP, you need reliable hosting that serves them efficiently. ImgLink fully supports WebP uploads with permanent direct links and CDN delivery. Upload your converted WebP files, get instant direct links, and embed them anywhere on the web.

Apply This Workflow on ImgLink

ImgLink is built for the exact workflow covered in this guide: fast uploads, permanent direct links, Cloudflare CDN delivery, and no-signup sharing when you need to move quickly. If you want to turn the advice above into a repeatable publishing system, start with one canonical hosted image URL and reuse it across docs, posts, forums, and social channels.

Recommended Next Steps

Use these related resources to keep building the same workflow across adjacent image-hosting topics:

• Free image converter
• WebP image hosting
• Free image compressor
• Image upload walkthrough
• Embed images in HTML, Markdown, and BBCode