Image Formats for SEO: JPEG vs. PNG vs. WebP vs. AVIF

TL;DR — An image formatThe file encoding used to store an image (JPEG, PNG, WebP, AVIF, SVG, GIF) — it drives file size and Core Web Vitals, but carries no direct ranking weight. is the type of file you save a picture as — JPEG, PNG, WebP, AVIF, and a few others. Switching to a “modern” format like WebP or AVIF won’t boost your rankings — Google has said so directly. What it does do is make the file smaller, which makes your page load faster, and speed is what actually helps. So pick the format that fits the picture: WebP for most photos, PNG for logos and screenshots that need sharp edges or transparency, SVG for icons.

What an image format is

When you save a picture, you save it as something — a .jpg, a .png, a .webp. That’s the format. Each one stores the image a little differently, and the choice changes three things you care about:

• How big the file is (a smaller file loads faster).
• Whether it can have a transparent background (a logo that sits on any color).
• Whether it can be animated (like an old-school GIF).

Search engines can read all the common formats, so you’re not picking one to “please Google.” You’re picking the one that keeps the file small without making the picture look worse.

The formats, in plain terms

• JPEG — the classic photo format. Works everywhere. Good for photographs, but it can’t do transparency.
• PNG — great for logos, screenshots, and anything with sharp edges or text, and it can have a transparent background. Files are bigger than JPEG for photos, though.
• WebP — a modern format that makes photos noticeably smaller than JPEG and also supports transparency. It works in basically every browser now. This is the safe everyday choice.
• AVIF — the newest and smallest of the bunch (often half the size of a JPEG). A tiny slice of visitors still can’t see it, so you pair it with a JPEG backup.
• SVG — for logos and icons. It’s drawn with math, not pixels, so it stays razor-sharp at any size and the file is tiny.
• GIF — the old animation format. Mostly outdated now, but still the most universally compatible way to show a simple animation.

The thing most people get wrong

There is no ranking “boost” for using WebP or AVIF. People hear “use WebP for SEO” and assume the format itself lifts them in the results. It doesn’t — Google’s John Mueller has said this plainly more than once. The benefit is smaller files → faster pages → better page-speed scores, and that speed is what helps. If you switched formats but the page didn’t actually get faster, there’s no SEO win to collect.

The simplest safe habit: use WebP for your photos, keep PNG for logos and screenshots, use SVG for icons, and don’t lose sleep over AVIF unless you’re squeezing every last kilobyte (in which case, add a JPEG fallback).

Want the full comparison — the compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits./transparency/animation/browser-support table for all six formats, the exact Google quotes, and a decision tree for which format to use when? Switch to the Advanced tab.

TL;DR — Image formatThe file encoding used to store an image (JPEG, PNG, WebP, AVIF, SVG, GIF) — it drives file size and Core Web Vitals, but carries no direct ranking weight. is not a ranking factor. Google’s John Mueller has confirmed there’s no SEO boost for AVIF, and WebP is only “fine for Image Search” — deliberately neutral language, not “better.” The real chain is: format → file size → page speed → Largest Contentful PaintLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good. / Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data. → the page-experience signals ranking systems actually use. Format sits several steps upstream. Pick by content type, not by “newest wins”: WebP is the safe default for photos (~96% support, ~25–35% smaller than JPEG, and does alpha transparency even in lossy mode — JPEG can’t); AVIF compresses furthest (~50% smaller than JPEG, ~94% support in 2026) but is CPU-heavy to encode and has no progressive renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM.; PNG for transparency and sharp-edged graphics/text; SVG for logos, icons, and diagrams; GIF only as the universal animation fallback. Serve modern formats via <picture> (AVIF → WebP → JPEG/PNG src) — the src fallback is the URL Google indexes. This is the format deep dive; the LCPLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good./fetchpriority/lazy-loading implementation lives in Image Optimization.

Does image format actually affect SEO?

Lead with the myth-bust, because it’s the reason most people land on this page.

Format is not a ranking factor. John Mueller has said this in at least three separate, independently-timed ways, and the through-line is the same every time — the format is not a signal, the speed it enables is. Following Google’s August 2024 announcement that AVIF was now supported in Search, Mueller confirmed there is no “SEO boost” for using AVIF over other supported formats (Search Engine Roundtable’s coverage) — the benefit is file-size reduction, which can help page speed, not a ranking preference for the container. Years earlier, on WebP, he was just as careful with his words: “WebP images are fine for Image Search” (SE Roundtable) — “fine,” not “better” or “preferred.” And when WebP images started showing up in Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results.’s “Crawled – currently not indexedStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed.” report, Mueller clarified that this is a general image-reporting quirk (images aren’t indexed as HTML pages), not a WebP-specific disadvantage — he “doesn’t believe the phenomenon is limited to WebP images” (Search Engine Journal’s write-up).

Google’s own primary image-SEO doc backs this up by omission: it lists the supported formats, points you to PageSpeed InsightsPageSpeed Insights (PSI) is a free Google tool at pagespeed.web.dev that reports two kinds of data for a URL: real-user field data from the Chrome UX Report and a single Lighthouse lab run with the 0–100 Performance score. Only the field Core Web Vitals are what Google uses for ranking. for performance, and never once ties format selection to a ranking factor. That absence is itself the evidence.

This is the same myth-bust I make at the hub level in Image SEOImage SEO is optimizing the images on your pages so search engines can discover, crawl, index, and rank them — in Google Images and visual search, and as part of standard web results. It spans file format, filenames, alt text, compression, responsive markup, structured data, and image sitemaps. and in the implementation guide, Image Optimization — and it’s worth stating precisely. Don’t say “format doesn’t matter.” Say “format doesn’t matter directly — it matters entirely through the speed and Core Web Vitals chain.”

The real chain: format → file size → speed → Core Web Vitals

Here’s the causal sequence, spelled out, because collapsing it is exactly how the myth spreads:

1. Format choice changes file size. The biggest single lever on image weight.
2. Smaller files load faster. Google’s own image doc notes images are “often the largest contributor to overall page size, which can make pages slow and expensive to load.”
3. Faster loads improve Largest Contentful Paint (LCP). The hero image is usually the LCP element, so its weight directly moves the metric. (I go deep on this in my Largest Contentful Paint guide — the why LCP is usually an image half.)
4. LCP feeds Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data., which is part of the page-experience signals Google’s ranking systems use.

Format is at the start of that chain — several steps upstream of anything ranking-adjacent. That’s the whole reason it isn’t a ranking factor by itself: too much has to go right in between, and if the page doesn’t actually get faster, nothing downstream changes.

The six formats compared

Most competing “2026 guides” cover only JPEG/PNG/WebP/AVIF and quietly get the browser-support numbers wrong (I’ve seen AVIF cited at “~74%,” which is years out of date). Here’s the full six-format matrix with current figures.

JPEG — the universal photographic fallback

Lossy-only, no transparency, no animation, and supported literally everywhere. JPEG is still the correct fallback at the end of a <picture> element and a perfectly fine choice for photographs when you’re not converting to a modern format. Its weak spot is baked into how lossy compression works: per Google’s Chrome team on web.dev, “lossy compression may be less effective with imagery containing sharp edges such as line art, similarly stark details, or text.” That’s precisely why JPEG is the wrong call for logos, screenshots, and text-heavy graphics — the artifactsClaude's feature for generating and publishing interactive mini-apps from chat. show.

PNG — lossless, transparency, graphics and screenshots

Lossless-only with full alpha transparency. PNG is right whenever you need crisp edges (logos, UI screenshots, text-in-image) or a transparent background and don’t want to take on modern-format fallback complexity. The trade-off: for photographs, PNG produces needlessly huge files for no visible quality gain over a well-tuned JPEG/WebP — losslessness is a cost you’re paying for nothing on a photo. (APNG does exist for animated PNG, but it’s a distinct, less-supported extension — not something to lean on.)

WebP — the modern safe default

WebP is the format I’d reach for first on most web photos. Google’s Chrome team is direct about why: “WebP often has better compression than JPEG, PNG, or GIF, offering both lossy and lossless compression.” And it clears JPEG’s biggest limitation — “WebP also supports alpha channel transparency even when using lossy compression — a feature the JPEG codec doesn’t offer.” Support is a non-issue: web.dev calls it “a widely supported format that works on all modern browsers” (~96% global in 2026). Roughly 25–35% smaller than JPEG at similar quality, and lossless WebP runs ~26% smaller than PNG. If you convert one thing, convert your photos to WebP.

AVIF — best compression, real trade-offs

AVIF wins on raw compression. Per web.dev, “AVIF supports both lossy and lossless compression, and tests have shown greater than 50% savings when compared to JPEG in some cases,” plus “Wide Color Gamut (WCG) and High Dynamic Range (HDR) features.” In 2026 its browser support sits around ~94% globally — Chrome (since 2020), Firefox (2021), Safari (16.4+, since 2023), and Edge (121+, January 2024) all render it. So it’s production-ready — with a fallback.

But “best compression” isn’t the only variable, and being honest about AVIF’s costs is what separates a useful guide from a listicle:

• Encoding is CPU-intensive. AVIF is slow to produce, which matters for large media libraries and CMSA content management system (CMS) is software that lets users create, manage, and publish digital content — like blog posts and pages — without writing raw code. WordPress, Drupal, and Joomla are the most common open-source CMS platforms. pipelines re-encoding thousands of assets.
• No progressive renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM.. Per MDN, an AVIF must fully download before it displays — unlike a progressive JPEG that paints a low-res version first. On a slow connection that can feel worse despite the smaller file.
• Animated-AVIF tooling is immature. The format supports animation (sometimes called AVIS), and Chrome, Edge, and Safari 16.4+ can play it — but Firefox still can’t as of 2026, and production tooling lags GIF/WebP animation.

SVG — vector graphics, icons, logos, diagrams

SVG is a different animal — it’s vector, described with math instead of a grid of pixels, so it scales to any size with zero quality loss and stays tiny for simple shapes. web.dev’s framing is the rule of thumb: SVGs are “most useful in cases where the image’s contents are line art, diagrams and charts, and other cases where there aren’t fine photographic details.” Logos, icons, and diagrams belong in SVG, full stop. Don’t use it for photographs — it isn’t built for them.

One thing that makes SVG genuinely different from the other five formats here: it’s XML, not pixel data, and per MDN’s own reference an SVG file can contain scripts and reference external resources — MDN specifically notes “there are additional restrictions when SVG is used” as a plain image (via <img> or CSS background-image) versus embedded inline or through an <iframe>/<object>. That restriction exists because an SVG loaded the ordinary “image” way is sandboxed from executing scripts or fetching externals, precisely to close off an XSS vector. If you ever accept SVG uploads from users (an icon library, a logo upload form), sanitize them before serving — strip <script> tags and external references — the same way you’d treat any other user-supplied markup, not the way you’d treat a JPEG.

GIF — legacy animation, when it’s still the right call

GIF is lossless LZW compression capped at a 256-color palette, with only binary (on/off) transparency. It’s the historical animation format, and for anything non-trivial it’s been superseded by animated WebP/AVIF (or, better still, actual video). Its one remaining edge is universal compatibility — if you need a simple animation to play everywhere with zero fallback logic, GIF is still the lowest-common-denominator choice. Otherwise, reach for animated WebP.

Whichever animation format you use, treat the semantics separately from the format decision: a looping GIF/animated image that conveys information needs alt textAlt text is the value of the `alt` attribute on an HTML `<img>` element — a short text substitute chosen for the image's purpose and context, not a literal description of what it shows. It makes images accessible to screen-reader users and helps search engines understand images, mainly for image search. describing what it shows, the same as a static image, and a purely decorative loop should be marked as such rather than read aloud as content by a screen reader. Neither of those is a format-compatibility question — they hold regardless of whether you ship GIF, animated WebP, or animated AVIF.

Which format should you actually use?

Match the format to the content, not to “which is newest.” The decision-tree tab lays this out as a flow, but the short version:

• Photographs → WebP (safe default), or AVIF with a JPEG fallback when you want maximum compression.
• Logos, icons, diagrams, line art → SVG.
• Screenshots, graphics with sharp edges or text, anything needing transparency without fallback complexity → PNG (or lossless WebP).
• Simple animation → animated WebP/AVIF where supported; GIF only as the universal fallback. (For anything richer, use video.)

One honest caveat on all the compression percentages in this article: they’re representative figures from web.dev’s and caniuse’s testing, not a guarantee for your images. Savings depend on the source image’s content (a busy photo compresses differently than a flat-color graphic) and the encoder settings you use. Treat “WebP is ~25–35% smaller” and “AVIF is ~50% smaller” as a starting expectation, then compare your own encodes at the quality settings you’ll actually ship — that’s the only way to know what a given format switch buys you on your own pages.

Implementing modern formats safely — the <picture> fallback

Don’t serve modern formats alone — serve them with fallbacks. The clean pattern is a <picture> element that offers AVIF first, WebP next, and ends in a plain <img src> pointing at a JPEG or PNG:

<picture>
  <source srcset="hero.avif" type="image/avif" />
  <source srcset="hero.webp" type="image/webp" />
  <img src="hero.jpg" alt="Descriptive alt text" width="1200" height="800" />
</picture>

The browser picks the first format it understands; older browsers and some crawlersA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. fall through to the src. Two things worth internalizing: that fallback src is the URL Google actually indexes for image search (Google parses the <img> even nested inside <picture>, but does not index CSS background-image), and this is where format selection hands off to the broader implementation work — sizing, compression settings, srcset/sizes, lazy loadingLazy loading defers loading of off-screen or non-critical resources — usually images and iframes — until they're about to enter the viewport. The native way to do it is the loading=\"lazy\" HTML attribute, which needs no JavaScript., and fetchpriority on the LCP image. That full how-to is deliberately not duplicated here; it lives in Image Optimization, and the responsive-serving mechanics (srcset, sizes, art direction) live in Responsive Images.

What Google and Bing officially support

Google’s supported-formats list and the August 2024 AVIF milestone

Google Search’s supported list is explicit: “Google Search supports images referenced in the src attribute of img in the following file formats: BMP, GIF, JPEG, PNG, WebP, SVG, and AVIF” (plus Base64 Data URIs). AVIF is the newest addition, and the date matters: Google didn’t support AVIF for Search at all until August 30, 2024, when it announced “AVIF is now a supported file type in Google Search” and that “you don’t need to do anything special to have your AVIF files indexed.” Before that date, AVIF wasn’t on the list — and per third-party coverage, using AVIF thumbnails could even cause Google to abort video indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. entirely. That’s a genuinely recent, dateable line: any competing guide written before mid-2024 and never updated is giving stale advice about AVIF’s safety.

Note how Google framed the announcement — purely as “we can now process this file type,” never as a ranking-signal launch. That’s the same non-ranking framing as the rest of the format list, and it’s why the Search Engine Journal headline “Google’s New Support For AVIF Images May Boost SEO” is a good cautionary example: the body correctly routes the “boost” entirely through file-size → Core Web VitalsWeb Vitals is Google's initiative (launched May 2020) for unified page-experience quality signals. Core Web Vitals — LCP, INP, and CLS — are the subset used in ranking; the rest (TTFB, FCP, TBT, Speed Index) are diagnostic, not ranking factors., but the headline is exactly how the format-equals-ranking myth gets amplified by well-meaning industry press.

Bing’s (limited) public guidance

Bing doesn’t publish a format-by-format comparison doc the way Google does. Its general Webmaster Guidelines treat page speed — including image weight — as a consideration, but there’s no Bing-specific “use WebP/AVIF” technical page, and I’m not going to invent one. Bing indexes and displays JPEG/PNG/WebP/GIF images in Bing Images without issue; its crawler support for modern formats is generally assumed to track Chromium-adjacent browser support, but unlike Google’s, it isn’t separately documented. This is the same honest gap I flag in Image Optimization — stated plainly rather than papered over.

Common myths about image formats and SEO

• “Switching to WebP/AVIF boosts rankings.” No — Mueller directly: no SEO boost for AVIF; WebP is “fine,” not “better.” The benefit is indirect, via file size → speed → Core Web Vitals.
• “AVIF is always best because it compresses best.” Overstated. AVIF is CPU-heavy to encode, has no progressive rendering, and was unsupported by Google Search until August 2024. Best compression isn’t the only variable.
• “PNG is always the safe, high-quality choice.” False as a blanket rule. PNG is right for graphics/transparency/text but produces bloated files for photographs, hurting load speed for zero visible gain.
• “You don’t need a fallback anymore — support is basically universal.” Mostly true for WebP; still worth a <picture> fallback for AVIF given the real (if small) ~6% gap plus crawler and older-device edge cases. Google explicitly recommends the fallback pattern.
• “Google penalizes older formats like JPEG/PNG.” False — JPEG, PNG, GIF, and BMP remain fully supported. There’s no penalty, only a missed speed opportunity versus modern formats.
• “AVIF can’t animate / WebP can’t do transparency.” Both false. WebP does alpha transparency even in lossy mode; AVIF supports animation (Safari 16.4+, Chrome, Edge — though not Firefox yet in 2026).
• “AVIF isn’t ready — it’s still a WebP-only world.” Outdated. AVIF sits around ~94% global support and has been indexable by Google Search since August 2024. Treat it as production-ready-with-fallback, not experimental.

Where this fits

This article is the format-comparison deep dive inside the Image SEOImage SEO is optimizing the images on your pages so search engines can discover, crawl, index, and rank them — in Google Images and visual search, and as part of standard web results. It spans file format, filenames, alt text, compression, responsive markup, structured data, and image sitemaps. cluster — it’s the canonical home for the six-format matrix and the ranking myth-bust. Its two siblings handle the adjacent jobs: Image Optimization is the implementation how-to (LCP, fetchpriority, lazy loading, compression, sizing), and Responsive Images covers srcset/sizes/<picture> mechanics for serving the right-sized image per device. The performance payoff of getting format right is really a Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data. story wearing an image hat.

AI summary

A condensed take on the Advanced version:

• Format is not a ranking factor. John Mueller has confirmed no SEO boost for AVIF, and WebP is only “fine for Image Search” — neutral wording, not “better.” Google’s own image doc never ties format to ranking.
• The real chain: format → file size → page speed → LCPLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good. / Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data. → page-experience signals. Format sits several steps upstream — that’s why it isn’t a ranking factor by itself.
• Six-format facts (2026): JPEG (lossy, no transparency, universal fallback); PNG (lossless, full alpha, graphics/screenshots); WebP (both compressionsCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits., alpha even in lossy mode, ~96% support, ~25–35% smaller than JPEG — the safe default); AVIF (best compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits., ~50% smaller than JPEG, ~94% support, but CPU-heavy, no progressive renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM., animation not in Firefox yet); SVG (vector — logos/icons/diagrams); GIF (legacy 256-color animation, universal fallback only).
• Pick by content type: photos → WebP (or AVIF + fallback); logos/icons → SVG; screenshots/transparency/text → PNG or lossless WebP; simple animation → animated WebP/AVIF, GIF as universal fallback.
• Serve with fallbacks: <picture> (AVIF → WebP → JPEG/PNG src). The src fallback is the URL Google indexes; Google indexes <img> (incl. inside <picture>), not CSS backgrounds.
• Official support: Google supports BMP, GIF, JPEG, PNG, WebP, SVG, AVIF; AVIF added Aug 30, 2024 (before that it could break video indexingA Google Search Console report showing how many of your indexed pages contain a video Google found, how many of those videos Google actually indexed, and the reasons blocking the rest. It only covers indexed pages and only appears once Google detects videos on the property.). Bing has no format-comparison doc — don’t invent one.
• Myths busted: format ≠ ranking boost; AVIF ≠ always best; PNG ≠ always safe; “no fallback needed” ≠ true for AVIF; older formats aren’t penalized; WebP does transparency and AVIF does animation.
• Scope: this is the format deep dive; LCPLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good./fetchpriority/lazy-loading how-to lives in Image Optimization, responsive mechanics in Responsive Images.

Official documentation

Primary-source documentation and reference material.

Google

• Google Images best practices — the supported-formats list (BMP, GIF, JPEG, PNG, WebP, SVG, AVIF), the <img>-vs-CSS-background indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. rule, and the extension-matches-file-type note. Makes no format-based ranking claim.
• Supporting AVIF in Google Search (Aug 30, 2024) — the announcement that AVIF is now supported in Search, Images, Discover, and News, with no special implementation needed.
• Image performance (web.dev, Google Chrome team) — the format mechanics: WebP/AVIF compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits., alpha-in-lossy, WCG/HDR, the lossy/lossless split, and why JPEG struggles with sharp edges/text.

Reference (accuracy backbone)

• Image file type and format guide (MDN Web Docs) — the rigorous format-by-format spec: MIME types, compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits., transparency, animation, progressive-renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. support, and use cases.
• caniuse.com — AVIF and caniuse.com — WebP — the version-by-version, current-global-percentage browser-support tables. Re-check these before quoting any support figure; they move continuously.

Bing / Microsoft

• Bing Webmaster Guidelines — general page-speed guidance; note Bing publishes no format-comparison-specific technical page.

Quotes from the source

On-the-record statements from Google. Where a page exposes the text, the link is a deep link that jumps to the quoted passage.

Google docs — supported formats and performance framing

• “Google Search supports images referenced in the src attribute of img in the following file formats: BMP, GIF, JPEG, PNG, WebP, SVG, and AVIF.” Jump to quote
• “images are often the largest contributor to overall page size, which can make pages slow and expensive to load.” Jump to quote

web.dev (Google Chrome team) — format mechanics

• WebP: “WebP often has better compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits. than JPEG, PNG, or GIF, offering both lossy and lossless compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits..” Jump to quote
• WebP transparency edge: “WebP also supports alpha channel transparency even when using lossy compression—a feature the JPEG codec doesn’t offer.”
• AVIF: “AVIF supports both lossy and lossless compression, and tests have shown greater than 50% savings when compared to JPEG in some cases.”
• JPEG’s weak spot: “lossy compression may be less effective with imagery containing sharp edges such as line art, similarly stark details, or text.”
• SVG’s ideal use: “Because SVG is a vector image formatThe file encoding used to store an image (JPEG, PNG, WebP, AVIF, SVG, GIF) — it drives file size and Core Web Vitals, but carries no direct ranking weight., they’re most useful in cases where the image’s contents are line art, diagrams and charts, and other cases where there aren’t fine photographic details.”

Google Search Central blog — AVIF support (Aug 30, 2024)

• “We’re happy to announce that AVIF is now a supported file type in Google Search, for Google Images as well as any place that uses images in Google Search.” Announcement
• “You don’t need to do anything special to have your AVIF files indexedStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. by Google.”

John Mueller, Google — format is no ranking boost

• On AVIF: there is no “SEO boost” for using AVIF files — the benefit is file-size reduction, which can help page speed, not a ranking preference. Coverage
• On WebP: “WebP images are fine for Image Search” — “fine,” deliberately not “better.” Coverage
• On the WebP “Crawled – currently not indexedA Google Search Console Page Indexing status meaning Googlebot fetched the page but Google decided not to index it — usually a content- or site-quality signal, not a technical error.” report: it’s a general image-reporting quirk (images aren’t indexed as HTML pages), and Mueller “doesn’t believe the phenomenon is limited to WebP images.” SEJ coverage

Which format should I use?

Work top-down. Match the format to what the image is, then add a fallback if you went modern.

1. Is it a logo, icon, diagram, or line art? → SVG. Vector scales without quality loss and stays tiny. Stop here.

2. Does it need to animate? → Animated WebP or AVIF where supported, with GIF as the universal fallback for simple loops. For anything richer than a short loop, use video (MP4/WebM), not an image formatThe file encoding used to store an image (JPEG, PNG, WebP, AVIF, SVG, GIF) — it drives file size and Core Web Vitals, but carries no direct ranking weight.. Stop here.

3. Is it a photograph? → WebP is the safe default (~96% support, no fallback strictly required). → Want maximum compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits. and can add a fallback? AVIF → WebP → JPEG via <picture>. → Need a single universal file with no fallback logic? JPEG.

4. Is it a screenshot, or a graphic with sharp edges, text, or transparency? → PNG (or lossless WebP). JPEG’s lossy artifactsClaude's feature for generating and publishing interactive mini-apps from chat. wreck sharp edges and text; PNG keeps them crisp and supports full transparency.

5. Did you choose AVIF or WebP for a photo? → Wrap it in <picture> with lower formats as <source>s and a JPEG/PNG <img src> fallback. That src is the URL Google indexes.

Quick reference by answer

The mental models

1. The causal chain — format → file size → speed → Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data.. Format sits at the start of a four-step chain, not at the ranking end of it: format choice changes file size → smaller files load faster → faster loads improve Largest Contentful PaintLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good. (LCPLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good.) → LCP feeds Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data., which is part of the page-experience signals ranking systems use. Collapsing this into “format affects rankings” is exactly how the myth spreads — format is several steps upstream, and if the page doesn’t actually get faster, nothing downstream changes. Use this model whenever you’re tempted to credit a format switch itself for a ranking move: ask which link in the chain actually happened.

2. Pick by content type, not by “newest wins.” The newest format isn’t automatically the right one — match the format to what the image is:

• Photographs → WebP (safe default), or AVIF with a JPEG fallback for maximum compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits..
• Logos, icons, diagrams, line art → SVG.
• Screenshots, sharp edges, text-in-image, transparency without fallback complexity → PNG (or lossless WebP).
• Simple animation → animated WebP/AVIF where supported, GIF only as the universal fallback (richer animation → video).

Running an image through this model before reaching for “just use AVIF, it’s newest” catches the cases where AVIF’s real costs — CPU-heavy encoding, no progressive renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM., and until August 2024 no Google Search support at all — outweigh its compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits. edge.

Image formats cheat sheet

The six formats at a glance (2026)

The <picture> fallback pattern

<picture>
  <source srcset="photo.avif" type="image/avif" />
  <source srcset="photo.webp" type="image/webp" />
  <img src="photo.jpg" alt="…" width="1200" height="800" />
</picture>

Fast facts

• No direct ranking boost for WebP/AVIF — the benefit is speed → Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data..
• Google supports BMP, GIF, JPEG, PNG, WebP, SVG, AVIF; AVIF added Aug 30, 2024.
• Google indexes <img> (incl. inside <picture>) — not CSS background-image.
• The <img src> fallback is the URL Google indexes.
• WebP does alpha transparency even in lossy mode; JPEG can’t do transparency at all.
• AVIF trade-offs: CPU-heavy encode, no progressive renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM., animation not in Firefox (2026).
• SVG is vector — never use it for photographs; never use JPEG for logos/text.

Format-choice checklist

A quick pass to confirm each image is in the right format and served safely:

• Photographs are WebP (or AVIF with a fallback) — not oversized PNG or JPEG.
• Logos, icons, and diagrams are SVG, not raster.
• Screenshots and text-in-image graphics are PNG or lossless WebP — not JPEG (whose artifactsClaude's feature for generating and publishing interactive mini-apps from chat. blur sharp edges and text).
• Anything needing transparency uses PNG, WebP, or AVIF — never JPEG.
• Modern formats (AVIF/WebP) are served via <picture> with a JPEG/PNG <img src> fallback.
• Every image lives in an <img> (or <picture>), not a CSS background-image, if you want it in image search.
• File extensions match the actual file type (watch out after batch conversion to .webp/.avif).
• No format was chosen for a ranking boost — the goal is smaller files → faster LCPLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good., verified in a real page-speed test, not the format label itself.
• Animations use animated WebP/AVIF (or video); GIF only where universal compatibility with no fallback is required.
• Browser-support assumptions re-checked against caniuse if you’re dropping a fallback.

Mistakes to avoid with image formats

Switching to WebP/AVIF expecting a ranking boost. Why it’s wrong: John Mueller has confirmed there’s no SEO boost for AVIF, and WebP is only “fine for Image Search” — deliberately neutral wording, not “better.” Format is not a ranking signal; the speed it enables is. What to do instead: convert for the file-size and Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data. win, and verify the win with a real page-speed test — not the format label itself.

Treating AVIF as always best because it compresses hardest. Why it’s wrong: best compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits. isn’t the only variable. AVIF is CPU-intensive to encode, has no progressive renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. (the image must fully download before it displays), and animated-AVIF tooling still isn’t supported in Firefox as of 2026. What to do instead: use AVIF with a <picture> fallback when you’re squeezing maximum compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits. and can absorb the encoding cost — otherwise WebP is the safer everyday default.

Assuming PNG is always the safe, high-quality choice. Why it’s wrong: PNG is lossless-only, so using it for photographs produces needlessly bloated files for no visible quality gain over a well-tuned JPEG/WebP — a real, avoidable speed cost. What to do instead: reserve PNG for transparency and sharp-edged graphics/screenshots/text; use WebP or JPEG for photos.

Dropping the fallback because “support is basically universal now.” Why it’s wrong: mostly true for WebP (~96%), but AVIF still sits around ~94% global support, plus older devices and some crawlersA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. don’t render it — a real, if small, gap. What to do instead: serve modern formats through a <picture> element ending in a JPEG/PNG <img src> fallback; that fallback is also the URL Google indexes.

Believing older formats like JPEG or PNG get penalized. Why it’s wrong: JPEG, PNG, GIF, and BMP remain fully supported by Google Search — there’s no penalty for using them, only a missed speed opportunity versus a smaller modern-format file. What to do instead: convert for the file-size benefit when it’s worth the effort, but don’t treat sticking with JPEG/PNG as a compliance risk.

Assuming WebP can’t do transparency or AVIF can’t animate. Why it’s wrong: both are false. WebP supports alpha channel transparency even in lossy mode — something JPEG can’t do at all — and AVIF supports animation in Chrome, Edge, and Safari 16.4+ (just not Firefox yet). What to do instead: check the actual per-format capability (the six-format table in the Advanced tab) instead of assuming based on format age.

Writing off AVIF as “still experimental” in 2026. Why it’s wrong: outdated. AVIF has been indexable by Google Search since August 30, 2024, and sits around ~94% global browser support. What to do instead: treat AVIF as production-ready with a fallback, not as something to avoid entirely.

Test yourself: image formats

Five quick questions on picking image formatsThe file encoding used to store an image (JPEG, PNG, WebP, AVIF, SVG, GIF) — it drives file size and Core Web Vitals, but carries no direct ranking weight. for SEO. Pick an answer for each, then check.

Resources worth your time

My related writing

• Image SEO: 12 Actionable Tips for More Organic Traffic — my Ahrefs image-SEO guide (formats, compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits., filenames, alt textAlt text is the value of the `alt` attribute on an HTML `<img>` element — a short text substitute chosen for the image's purpose and context, not a literal description of what it shows. It makes images accessible to screen-reader users and helps search engines understand images, mainly for image search., sitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing., responsive images, schema, lazy loadingLazy loading defers loading of off-screen or non-critical resources — usually images and iframes — until they're about to enter the viewport. The native way to do it is the loading=\"lazy\" HTML attribute, which needs no JavaScript.).
• Largest Contentful Paint (LCP) — why the LCPLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good. element is usually an image, and how format-driven file size feeds it. The performance chain this article’s myth-bust hangs on.
• The Beginner’s Guide to Technical SEO — where images and Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data. sit in the broader technical picture.

My speaking

• “Image SEOImage SEO is optimizing the images on your pages so search engines can discover, crawl, index, and rank them — in Google Images and visual search, and as part of standard web results. It spans file format, filenames, alt text, compression, responsive markup, structured data, and image sitemaps.” (Visme webinar, 2021) — my dedicated talk on optimizing images for search, including format and compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits. choices.

Official

• Google Images best practices — the supported-formats list and indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. mechanics.
• Supporting AVIF in Google Search (Aug 2024) — the AVIF support announcement.
• web.dev — Image performance (Google Chrome team) — the format-mechanics reference behind the comparison table.

From around the industry

• Image file type and format guide (MDN Web Docs) — the most rigorous format-by-format spec table on the web; the accuracy backbone for the six-format comparison.
• caniuse.com — AVIF / caniuse.com — WebP — live, version-by-version browser-support tables with current global percentages.
• Google’s New Support For AVIF Images May Boost SEO (Search Engine Journal, Roger Montti) — useful as a case study of how the “format = ranking boost” framing gets amplified; the body correctly routes the benefit through Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data..
• Google’s John Mueller Clarifies WebP Image Indexing Confusion (Search Engine Journal) — why WebP images show as “Crawled – currently not indexedA Google Search Console Page Indexing status meaning Googlebot fetched the page but Google decided not to index it — usually a content- or site-quality signal, not a technical error.,” and why it’s not a WebP-specific problem.
• Google Search Now Supports AVIF Images (Search Engine Roundtable) — coverage of the AVIF milestone and Mueller’s “no SEO boost” point.
• AVIF vs. WebP: 4 Key Differences and How to Choose (Cloudinary) — a solid implementation-oriented AVIF-vs-WebP comparison.
• r/TechSEO — the community for image-format and performance debugging.

Image Format

The file encoding used to store an image (JPEG, PNG, WebP, AVIF, SVG, GIF) — it drives file size and Core Web Vitals, but carries no direct ranking weight.

Parent concept: Image SEO · Related: Image SEO, Core Web Vitals, LCP

Image Format

An image format is the file encoding used to store a raster or vector image — the choice determines the compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits. type (lossy vs. lossless), whether transparency and animation are supported, how small the file is at a given visual quality, and which browsers and crawlersA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. can render it.

For SEO, the format itself carries no direct ranking weight — Google’s John Mueller has confirmed this multiple times. But format choice is one of the biggest levers on file size, and file size drives Largest Contentful PaintLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good. (LCPLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good.) and the rest of Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data., which are part of the page-experience signals Google’s ranking systems use. So format doesn’t matter directly; it matters entirely through the speed chain.

The common web formats: JPEG (lossy, photographs, universal fallback); PNG (lossless, transparency, graphics and screenshots); WebP (both lossy and lossless, transparency even in lossy mode, the safe modern default); AVIF (best compressionCompression (HTTP content encoding) shrinks text-based responses — HTML, CSS, JS, JSON, SVG, XML sitemaps — before they're sent over the network, using an algorithm like Gzip, Brotli, or Zstd, so the browser or crawler downloads fewer bytes. It's not a ranking factor, but it speeds up page loads and helps pages stay under crawler fetch limits., roughly half the size of JPEG, with real encode-cost trade-offs); SVG (vector, logos, icons, and diagrams that scale without quality loss); and GIF (legacy 256-color animation, largely superseded by animated WebP/AVIF). Google Search supports all of these — BMP, GIF, JPEG, PNG, WebP, SVG, and AVIF — with AVIF added in August 2024.

The practical rule is to serve modern formats with fallbacks using a <picture> element (AVIF, then WebP, then a JPEG/PNG <img src>), and to match the format to the content type rather than assuming the newest format always wins.

Parent concept: Image SEO · Related: Image SEO, Core Web Vitals, LCP

Changelog