Short answer: ShortPixel and Imagify are the most balanced picks for most sites – good compression, modern format support, sensible free tiers, and they have not made a sudden architectural change in years. EWWW Image Optimizer is the right pick if you want compression to happen on your own server instead of a third-party API. Optimole is the right pick if you want a CDN bundled with the optimizer and do not mind your image URLs running through a third-party service. Smush is the most-installed option but the recent v4 rewrite has been bumpy, and most of what people actually want from it (WebP, AVIF, CDN) is paywalled. The plugin you pick matters less than how it processes your images – lossy vs lossless, on-server vs cloud-API, regen-on-upload vs bulk-rewrite, and whether it serves modern formats with a fallback or just converts files in place.
| Plugin | Free / Paid | Best for | Skip if |
|---|---|---|---|
| ShortPixel | Free 100/month + paid (credits or unlimited) | Most sites – balanced compression, WebP+AVIF, supports both API and self-host | You need on-server processing without an API roundtrip |
| Imagify | Free 20MB/month + paid (from $5.99/month) | WP Rocket users wanting matching ecosystem, sites valuing simple UI | You have a large media library and limited budget – quotas are MB-based, not image-count |
| EWWW Image Optimizer | Free unlimited (local) + paid Easy IO CDN | Sites where you want compression to run on your own server, no API dependency | Your host blocks PHP
exec()
and you do not want a paid API |
| Smush | Free + Pro (in WPMU DEV bundle) | Sites already on the WPMU DEV ecosystem, basic lazy-load + compression | You need WebP/AVIF and CDN without paying for the bundle |
| Optimole | Free 2,000 visits/month + paid (visit-based) | Sites wanting CDN + image optimization in one product | You do not want image URLs proxied through a third-party domain |
The honest framing most image-optimization roundups skip: every plugin in this list does roughly the same job. The differences are not in compression algorithms (all five hit broadly similar quality-per-byte numbers on real-world JPEGs and PNGs). The differences are in where the processing happens, what gets paywalled, and how the optimized images are served to the browser.
This means the questions worth asking when picking a plugin are different from what the marketing pages emphasize:
- Where does compression happen? On your server (EWWW local mode) or via a third-party API (Smush, ShortPixel, Imagify default behavior, Optimole)? On-server keeps your data on your machine and avoids API roundtrips, but only works if your host allows the binaries that do the compression.
- What does free actually cover? Most plugins lose their best features (WebP, AVIF, CDN, full-size compression) at the free tier. Read the pricing page before installing, not after.
- Is there a CDN included? Plugins that bundle a CDN (Optimole, Easy IO from EWWW, Smush Pro) take over how images are served, not just how they are stored. This is a bigger architectural choice than picking a plugin.
- What happens when you uninstall? Optimized files stay on the server (for self-hosted compression) or your URLs revert to the originals (for cloud CDN plugins). Make sure you know which your plugin does.
Why how the plugin processes your images matters more than which one you pick#
Image optimization is one of the few WordPress plugin categories where the architectural choice (on-server compression vs cloud API vs CDN proxy) changes more about your site than the plugin name does. Pick the wrong architecture and the right plugin still produces the wrong result.
There are three patterns:
On-server compression. The plugin uses binaries already installed on your server (jpegtran, optipng, pngquant, gifsicle, cwebp) to compress images. The compressed file replaces the original (or sits next to it). Pros: no API quota, no third-party dependency, no data leaves your server. Cons: requires your host to allow PHP
exec()
and to have the binaries installed; CPU cost runs on your server; AVIF in particular is hard without specialized libraries. Only EWWW Image Optimizer offers this as a default mode in 2026.
Cloud-API compression. The plugin sends your image to a third-party API, which compresses it and returns the result. The compressed file replaces the original on your server. Pros: consistent quality, no server CPU cost, supports modern formats (WebP, AVIF) regardless of your server config. Cons: API quotas and pricing, API roundtrip latency on upload, your images leave your server during processing. Smush, ShortPixel, Imagify, and EWWW’s API mode all use this pattern.
CDN proxy. The plugin does not store optimized images on your server at all. It rewrites your
<img>
URLs to point at a CDN-served version, where the optimization happens on the fly based on the visitor’s browser, screen size, and network conditions. Pros: best performance for image-heavy sites, automatic WebP/AVIF based on browser support, automatic responsive sizing, CDN included. Cons: visitor-volume-based pricing, vendor lock-in (your image URLs depend on the third-party domain), uninstalling means broken images until you do a cleanup. Optimole is built around this pattern; EWWW’s Easy IO and Smush’s CDN are paid add-ons that do the same thing.
For most sites running on standard managed WordPress hosting, cloud-API compression is the path of least resistance. You install the plugin, run a bulk optimization once on existing images, and new uploads get optimized automatically. For sites where image delivery is performance-critical (photography portfolios, image-heavy e-commerce), the CDN-proxy pattern usually pays off, but the pricing model is visit-based, not image-based, so it scales with traffic rather than with media library size.
For sites on hosts that allow PHP
exec()
(most managed WordPress hosting does, by the way – the supported list at docs.ewww.io covers the major names), on-server compression is the cheapest and most private option, and EWWW is the only plugin in this list that genuinely supports it as a free, unlimited mode.
How we picked these five plugins#
The WordPress plugin directory has hundreds of “image optimization” plugins. Most of them are abandoned, broken on PHP 8.x, or thin wrappers around a single API. We covered the five with active development, meaningful user bases (200,000+ active installs minimum), and architecturally distinct approaches: API-based premium, API-based with on-server fallback, CDN-proxy, ecosystem-bundled, and the only-real-on-server option.
What we deliberately skipped: TinyPNG (good service but the WordPress plugin is a thin wrapper, see ShortPixel for the more complete option), Kraken.io (no plugin updates since 2023, abandoned), reSmush.it (operated as a free public API with reliability problems), and the dozens of “image optimizer” plugins on CodeCanyon that are clearly thin wrappers around the same handful of compression libraries.
For each plugin: what it does, when it is the right pick, when it is not, and what to expect after installing.
ShortPixel Image Optimizer (free 100/month + paid)#
ShortPixel is the closest thing this list has to a default recommendation. The plugin connects to ShortPixel’s cloud API for compression, supports JPG, PNG, GIF, PDF, and WebP+AVIF conversion, has a sensible free tier (100 images per month), and the paid plans are credit-based rather than visit-based, which makes them predictable.
The compression options are clear: Lossy (default, 60-80% reduction with imperceptible quality loss for typical web use), Glossy (35-55% reduction, designed for photographer portfolios where finer detail matters), or Lossless (20-30% reduction, no quality change at all). Pick once, and the plugin uses that level for every new upload.
WebP and AVIF generation is included on the free tier. The plugin can serve them via Apache rewrite rules, picture tags, or a JavaScript replacement script – the picture-tag mode is the most universally compatible. Bulk optimization handles existing media libraries efficiently and supports resuming if the bulk run is interrupted.
Use it if: You want a balanced default that handles most cases without configuration drama. Sensible free tier, sensible paid tier, modern format support, no surprises.
Do not use it if: You need on-server processing with no third-party API call. ShortPixel’s plugin has a “shortpixel-image-optimiser-tools” addon that runs binaries on your server, but it is a community-supported alternative that requires your host to allow
exec()
and is more complicated than just using EWWW for that case.
What you get from the free version: 100 images per month (1 image with thumbnails counts as roughly 5-7 credits because each thumbnail is a separate image), all compression levels, WebP+AVIF generation, picture-tag delivery. Bulk optimization works on the free tier but is rate-limited.
Common gotchas: The credit system counts each thumbnail size as a separate credit, so a single Media Library upload of one photo with five WordPress-generated sizes consumes about 5-6 credits. A 1,000-photo library can take 5,000-6,000 credits to fully optimize. Plan the credit purchase accordingly. Also: the plugin sends images to ShortPixel servers in the EU (Romania, primarily), which matters for some compliance scenarios.
Processing model: Cloud API. Each new upload triggers an API call to ShortPixel, which returns the optimized image and stores no copy on its servers (per their privacy policy). Original images can be backed up locally before optimization in case you want to restore.
Imagify (free 20MB/month + paid)#
Imagify is built by WP Media, the same company that makes WP Rocket. The two products share a design language and integrate well, which matters if you are already on the WP Rocket caching plugin. The image optimization itself is solid – JPG, PNG, GIF, PDF compression with lossy or lossless options, WebP and AVIF conversion, and a bulk optimizer that works asynchronously in the background.
The free tier is 20MB of images per month, which works out to roughly 200 images depending on average size. This is the smallest free tier in this list, which makes Imagify mostly a paid product in practice. The paid plans start at $5.99/month for 500MB.
The plugin’s Smart Compression mode picks the right compression level per image based on content, which is genuinely useful for mixed media libraries (photos, screenshots, illustrations). For the AVIF format, Imagify can serve AVIF to supporting browsers and fall back to WebP for browsers that do not support AVIF, which gives you next-gen format coverage across all browsers without separate fallback configuration.
Use it if: You are already on WP Rocket and want a matching image optimizer. The integration is good, the compression quality is good, and the UI is the simplest in this list.
Do not use it if: You have a large existing media library (the 20MB free tier will not get you very far) and a tight budget. ShortPixel’s free tier extends further per month for typical photo sizes.
What you get from the free version: 20MB/month, all compression levels, WebP+AVIF conversion with AVIF-then-WebP fallback. Bulk optimization works but counts against the monthly quota.
Common gotchas: The 20MB monthly free tier is genuinely small – one upload of an unoptimized photo can be 5-8MB. New users typically burn through it on their first bulk run. The plugin shows the quota usage clearly, but the upgrade prompt becomes unavoidable on any site with more than a handful of images. Also: Imagify’s API is in the EU (France), same compliance considerations as ShortPixel.
Processing model: Cloud API. Same model as ShortPixel – upload to Imagify, optimization happens on their servers, optimized image returned. Original backup option is on by default.
EWWW Image Optimizer (free unlimited local + paid)#
EWWW is structurally different from the rest of the list. By default, it runs the compression binaries (jpegtran, optipng, pngquant, gifsicle, cwebp) on your own server, which means: no API quota, no monthly limits, no data leaves your server. If your host allows PHP
exec()
and has the binaries installed, this is genuinely free and unlimited.
If your host blocks
exec()
(rare on managed WordPress hosting, common on shared cPanel hosts), EWWW falls back to its cloud API, which uses a credit system similar to ShortPixel. The plugin also offers Easy IO, a paid CDN add-on that rewrites your image URLs to a CDN-served version with on-the-fly WebP and AVIF conversion – this is the same pattern as Optimole, but bolted onto an already-installed EWWW.
The local-mode compression supports JPG, PNG, GIF, SVG, and WebP conversion via the cwebp binary. AVIF requires the paid Easy IO CDN – on-server AVIF generation needs specialized libraries that are not commonly preinstalled.
Use it if: Your host allows PHP
exec()
and you want compression to happen on your server with no API quota or third-party data flow. Also: if you are technically comfortable enough to verify that your host’s installed binaries are working (the plugin has a “Server Status” page that shows what is and is not available).
Do not use it if: Your host blocks
exec()
(the local mode falls back to API mode anyway, at which point you might as well use ShortPixel or Imagify for a more polished UX). Also: if you need on-server AVIF without paying for Easy IO.
What you get from the free version: Unlimited local compression (JPG, PNG, GIF, SVG), WebP conversion via cwebp, lazy loading with auto-scaling, optimization of images outside the Media Library (theme images, custom folders), bulk optimizer.
Common gotchas: The “missing tools” notice on the settings page is common during initial setup – the plugin tries to auto-install the binaries to wp-content, and some hosts block this. If that happens, ask your host to install jpegtran, optipng, gifsicle, and cwebp, or fall back to the cloud API. Also: EWWW’s UI is the most cluttered of the five plugins listed here. Power users like the granular options; new users find the settings overwhelming.
Processing model: On-server (default) or cloud API (fallback) for compression. Easy IO is a separate CDN proxy add-on with its own architectural model.
Smush (free + Pro in WPMU DEV bundle)#
Smush has 1+ million active installs, which makes it the most-installed plugin in this list. Whether that means anything is debatable – much of that install base predates the v4 UI rewrite that landed in April 2026, and the recent reviews are mixed (the v4 dashboard has reliability complaints in the WordPress.org reviews). The free version handles compression, lazy loading, and basic image scanning. WebP and AVIF conversion, the global CDN, and full-size image compression are all paywalled into the WPMU DEV Pro bundle.
The free version of Smush has one specific limitation worth knowing: images over 5MB are skipped entirely. For sites that upload professional photography or 4K screenshots regularly, this means the largest files – the ones most in need of optimization – are exactly the ones the free version will not touch. Pro raises this to 256MB.
Use it if: You are already on the WPMU DEV bundle (which includes Smush, Hummingbird, Defender, and other WPMU DEV plugins) and want a single-vendor stack. The bundle pricing is reasonable if you use multiple WPMU DEV products.
Do not use it if: You only need image optimization. The free version’s most-wanted features (WebP, AVIF, CDN, full-size compression) are all behind the bundle paywall, and the dedicated alternatives (ShortPixel, Imagify, Optimole) handle those features at the free or basic-paid tiers without requiring a bundle commitment.
What you get from the free version: Lossy and lossless compression for images under 5MB, lazy loading, basic image scanning, integration with major page builders. No WebP, no AVIF, no CDN, no full-size compression.
Common gotchas: The 5MB limit on the free version catches a lot of users by surprise. The v4 UI rewrite in April 2026 has been disruptive – early reviews mention scans stuck at 0% and bulk optimization stopping after one image. If you install Smush and the v4 dashboard does not work cleanly on your site, the older UI is no longer available, so the workaround is either troubleshooting through WPMU DEV support or switching plugins.
Processing model: Cloud API (Smush servers) for compression. CDN proxy in Pro mode.
Optimole (free 2,000 visits/month + paid)#
Optimole is structurally a CDN with image optimization built in, not an image optimization plugin with a CDN bolted on. The plugin does not store optimized images on your server – it rewrites your
<img>
URLs to point at Optimole’s AWS CloudFront-backed CDN, which serves a per-visitor optimized version (correctly sized for the screen, in WebP or AVIF if the browser supports it).
This architecture has consequences. On the upside: bandwidth-heavy image delivery moves off your origin server, your Lighthouse scores improve immediately because images load from a 450+ POP CDN, and you do not need to bulk-process anything because optimization happens on first request and is cached at the edge. On the downside: your image URLs now look like
https://mlflrwjuhfo.i.optimole.com/cb:abc/w:auto/h:auto/q:mauto/[your-original-URL]
and depend on Optimole’s domain remaining alive. Uninstalling without a cleanup leaves broken images.
The free tier is 2,000 monthly visits, which is genuinely small for any site running organic search traffic. Paid plans scale with monthly visit count, starting at 40,000 visits. This is a different pricing model than image-count or storage-based plans, so it suits sites with moderate traffic and large image libraries better than it suits sites with high traffic and few images.
Use it if: You want a CDN bundled with image optimization and are willing to route image URLs through a third-party domain. Photography sites, e-commerce sites with hundreds of product images, and travel/recipe blogs with image-heavy content all benefit substantially.
Do not use it if: You already have a CDN and do not want a second CDN layer for images specifically. Also: if your traffic is high but your image library is small, the visit-based pricing model is unfavorable – a content site doing 200,000 visits/month with a 200-image library will pay more for Optimole than for the same library running through a credit-based plugin.
What you get from the free version: Full CDN delivery, WebP+AVIF conversion, smart cropping, lazy loading, adaptive image sizing – all features. The limit is purely on the monthly visit count to your site.
Common gotchas: Image URLs change to Optimole’s domain, which means: if you have hardcoded image URLs anywhere outside
<img>
tags (in CSS, in old post bodies before the plugin was installed, in feeds, in cached HTML), those will not be rewritten. The plugin handles
<img>
tags, picture elements, srcset, and most page builder output, but anything that bypasses the standard rendering path is at risk. Also: Optimole’s AVIF fallback to WebP to JPG works automatically based on Accept headers, but some aggressive caching layers can serve the wrong format if not configured to vary on Accept.
Processing model: CDN proxy. Optimization happens on the edge, on first request per unique image+size+format combination, and is cached at AWS CloudFront’s POPs.
Quick reference: which plugin for which scenario#
| Scenario | Primary pick | Secondary |
|---|---|---|
| Standard WordPress site, modest media library, balanced budget | ShortPixel | Imagify |
| Already on WP Rocket, want matching ecosystem | Imagify | ShortPixel |
| Already on WPMU DEV bundle | Smush Pro | (no alternative within the bundle) |
| Want compression on your own server, no API | EWWW Image Optimizer (local mode) | (no alternative – only EWWW does local-first) |
| Photography portfolio, image-heavy, performance-critical | Optimole | ShortPixel + Cloudflare CDN |
| E-commerce with thousands of product images | Optimole or ShortPixel API + dedicated CDN | EWWW + Easy IO |
| Tight budget, large existing library, need one-time bulk optimization | EWWW (local) if exec() works, else ShortPixel one-off credits | Imagify monthly cycle |
| Need AVIF specifically | Optimole or ShortPixel | Imagify |
| GDPR/data-residency concerns about images leaving your server | EWWW local mode | (none – all others use cloud APIs) |
| Need to serve WebP/AVIF on a host without rewrite-rule access | Optimole | ShortPixel with picture tags |
| Multiple sites, want shared quota | Imagify (account-wide quota) | ShortPixel (account-wide credits) |
| Sites where you may uninstall later | EWWW or ShortPixel (files stay optimized on server) | (avoid Optimole – URLs revert) |
How long does it take to see results#
Image optimization is one of the fastest WordPress changes to verify. Compression results are visible immediately on new uploads, and you can re-test page weight before and after a bulk run.
| Metric | First page after install | After bulk optimization | After 30 days |
|---|---|---|---|
| Total page weight (image-heavy page) | -10% to -25% | -40% to -70% | Stable at the bulk-run level |
| LCP (Largest Contentful Paint) | -0.2s to -0.5s | -0.5s to -1.5s | Stable, depends on hero image |
| GTmetrix “Properly size images” | Often still flagged on existing media | Resolved if responsive sizes are correctly generated | Resolved |
| GTmetrix “Serve in next-gen formats” | Still flagged until WebP/AVIF enabled | Resolved (with WebP) or partially resolved (with AVIF where supported) | Resolved |
| Lighthouse Performance score | +3 to +8 points | +10 to +25 points (image-heavy sites) | Stable |
| Server disk usage | -20% to -50% (if originals replaced) | Same as immediate result | Stable |
The numbers above assume a baseline of unoptimized JPEGs in the 1-3MB range with no WebP/AVIF previously generated. Sites that already had some image optimization (a previous plugin, manual optimization, or theme-level conversion) will see smaller improvements because the easy wins are already done.
The largest impact in the first week comes from running the bulk optimizer on the existing media library. New uploads benefit going forward, but the existing library is where the size savings are. Plan for the bulk run to take hours on large libraries (1,000+ images) – cloud-API plugins are throttled by their API rate limits, and on-server plugins are throttled by your server’s CPU.
Common mistakes when picking and configuring an image optimization plugin#
- Installing two image optimization plugins simultaneously. Smush plus ShortPixel plus EWWW all running at once is not “extra optimization” – it is conflict. The plugins fight over the upload hook, optimize images already optimized by the other plugin (sometimes degrading quality through repeated lossy passes), and produce confusing logs. Pick one. Run a test bulk on a few images. Verify quality. Commit.
- Picking the wrong compression level. Lossless compression on web JPEGs is mostly wasted – the savings are 5-15% versus 60-80% for lossy at imperceptible quality loss. Photographers should use lossless (or Glossy in ShortPixel’s terminology) for portfolio work. Everyone else should use lossy.
- Forgetting to back up originals before bulk-optimizing. All the plugins offer “keep original” as an option. Most have it on by default. Verify before running a bulk operation on a 10,000-image library, because lossy optimization is irreversible without the original.
- Treating WebP/AVIF as a substitute for compression. WebP and AVIF are formats – they are smaller than JPEG by default, but they still compress further. A “WebP image” can be unoptimized and large just like a JPEG. Make sure your plugin is both converting format and compressing within the new format.
- Generating WebP without a fallback. Older browsers (anything older than Safari 14, IE 11, Android browsers from before 2019) do not support WebP. Always generate WebP via picture tags or rewrite rules that fall back to the original JPEG/PNG, never replace the original file with a WebP file. The same applies to AVIF, except the browser-support floor is even higher.
- Ignoring lazy loading. Modern WordPress (5.5+) ships with native browser lazy loading via
loading="lazy". Most of these plugins also offer their own lazy loading, which can sometimes conflict with the core implementation. Pick one – either rely on native lazy loading and turn the plugin’s off, or turn off the core feature and rely on the plugin’s. Both running at once produces double-defer and can break above-the-fold images. - Running lazy loading on the LCP image. The Largest Contentful Paint image (usually the hero image at the top of the page) must NOT be lazy-loaded. Most plugins have an “exclude above-the-fold images” setting. Verify it is on. A lazy-loaded LCP is a Core Web Vitals regression.
- Picking a CDN proxy plugin without understanding the URL implications. Optimole, Easy IO, and Smush CDN all rewrite your image URLs. This is fine while the plugin is active. If you uninstall, you need a cleanup process to revert the URLs, otherwise images break. Plan the exit strategy before installing.
- Assuming compression results are visible immediately on existing pages. Cached HTML (from your caching plugin or CDN) keeps the old image URLs and dimensions. After running a bulk optimization, clear the page cache. Otherwise the visible page weight does not change until the cache expires naturally.
- Optimizing PDFs and not knowing it. ShortPixel and Imagify can optimize PDF files in the Media Library by default. This is sometimes desirable (a 50MB scanned PDF compresses well), sometimes not (a designed PDF brochure may visibly degrade). Check the settings if you have PDFs you care about preserving exactly.
Summary#
For most WordPress sites in 2026, ShortPixel is the safest default – balanced free tier, supports WebP and AVIF, sensible paid pricing, and the architectural choice (cloud API) suits the vast majority of managed WordPress hosting. Imagify is the close second, especially for sites already on WP Rocket. EWWW is the right pick for sites that need on-server processing or have data-residency concerns about images leaving the origin. Optimole is the right pick for image-heavy sites where bundling a CDN is more valuable than keeping image URLs on your own domain. Smush is mostly a “if you are already in the WPMU DEV ecosystem” pick – the free version is too feature-limited for most modern WordPress performance work, and the recent v4 rewrite has reliability issues that have not yet stabilized.
But the bigger lesson is the one most plugin roundups skip: the architectural choice (where compression happens, how optimized images are served) decides more about your site than the plugin name does. Pick the plugin that fits the architecture you want, not the one with the largest install count or the most features in the marketing copy.
For the broader WordPress performance picture, see how to speed up WordPress: a complete optimization guide. For diagnosing image-related slowdowns specifically, why is my WordPress site so slow: diagnostic guide walks through the network-tab and Core Web Vitals signals that point to image issues. For the day-to-day workflow of adding images to WordPress (which the plugins above optimize after the fact), how to add images to WordPress covers the upload mechanics, and how to add alt text to images in WordPress covers the accessibility piece that no compression plugin handles for you. For the rest of the optimization stack, see also best WordPress caching plugins: an honest comparison, best WordPress backup plugins (free and paid), best WordPress newsletter plugins (free and paid), and best WordPress popup plugins (with performance and accessibility in mind).