We serve modern formats. Why does the report show the old one?

Either the pipeline does not negotiate on what the client accepts, or it has no modern version stored for those files. Both produce the same observation, and checking what a browser receives for the same URL separates them.

Should I convert every image?

Work from the weight ranking instead. The gain is proportional to the file size, so converting the largest few captures most of it and converting the long tail captures very little.

Is a vector always better than a raster?

For shapes, logos and icons, yes — it scales without loss and is usually smaller. For photographs it is not an option at all, since there is nothing to describe geometrically.

Tools

Image format checker

An image format checker reads the format and the compression of every image a page really delivered, and reports which of them are served in an older format where a modern one would transfer substantially fewer bytes at the same visual quality. The measurement has one property worth understanding before reading it: format is often negotiated, so what a scan receives depends on what it said it accepted — and a site can be serving modern formats to browsers while an audit sees the fallback.

What is measured on each file

The format really returned, read from the response rather than from the file extension. A file named with one extension and served as another format is common behind an image CDN.

The transferred size, and how it compares with what the same image would cost in a modern format at comparable quality.

Whether the image appears over-compressed or under-compressed relative to its dimensions, which is a different finding from the format itself.

Whether images are delivered through a dedicated image service, which changes how much of the above is under your direct control.

Why negotiation makes the result client-dependent

A well-configured image pipeline inspects what the client says it accepts and returns the best format that client supports.

That means the same URL returns different bytes to different clients, which is correct behaviour and makes a single measurement a measurement of one client's experience.

A scan that advertises support for modern formats and receives an older one is seeing either a pipeline that does not negotiate, or one that has nothing better stored.

The picture element is the alternative approach: candidates declared in the markup rather than negotiated in the response. Both are valid, and they fail differently — a missing source element is visible in the HTML, a non-negotiating server is not.

Which is why the finding is phrased as what was delivered, not as what your visitors receive.

What a clean result looks like

Photographic images delivered in a modern format to clients that accept one, with a fallback for those that do not.

Compression tuned to the content: photographs tolerate far more compression than screenshots or images containing text.

Illustrations and icons served as vectors where they are vectors, since rasterising a shape is spending bytes to lose quality.

No image delivered at a size that is mostly metadata — a large file carrying a small picture, which usually means an export preset nobody revisited.

Choosing what to act on

Start from the weight ranking rather than the format list. Converting a small image saves a small number of bytes regardless of how much better the new format is.

The largest photographic image on the most-visited page is almost always where the whole gain is.

Converting an image that is already well compressed gains far less than the format comparison suggests, because the comparison assumes a typical encoding rather than yours.

An image service is usually the cheaper answer than converting files by hand, because it handles negotiation, fallback and future formats without another migration.

What VeriFixScan uses

`images.webp` and `images.avif` report adoption of the modern formats. `images.compression` reads how each image is compressed.

`images.weight` measures each file and `images.oversized` identifies the ones substantially larger than their rendered box, since format and dimensions are separate causes of the same symptom.

`images.cdn` reports whether images are delivered through a dedicated image service. `images.broken` reports images that failed to load at all.

The limits, stated plainly

The format reported is the one delivered to this scan. A negotiating pipeline may serve something better to a browser, and the report describes what arrived rather than what everyone receives.

The saving estimated from a format comparison assumes a typical encoding. An image already encoded carefully gains less than the figure suggests.

Visual quality is not assessed. Whether a more compressed version is acceptable is a judgement no automated check makes.

Images loaded by script after the page renders may be outside the inventory.

Frequently asked questions

We serve modern formats. Why does the report show the old one?: Either the pipeline does not negotiate on what the client accepts, or it has no modern version stored for those files. Both produce the same observation, and checking what a browser receives for the same URL separates them.
Should I convert every image?: Work from the weight ranking instead. The gain is proportional to the file size, so converting the largest few captures most of it and converting the long tail captures very little.
Is a vector always better than a raster?: For shapes, logos and icons, yes — it scales without loss and is usually smaller. For photographs it is not an option at all, since there is nothing to describe geometrically.

Sources

VeriFixScan crawls a site and applies its checks to every page it reaches, keeping the evidence behind each finding. Scanning one website is free.

Scan a website