Plugins Plugin hub Backup SEO Caching Security Forms WooCommerce Images Best backup plugins
Hosting Hosting directory Shared Managed Cloud India
Themes & builders Compare Rank Math vs Yoast
Tools All tools Hosting finder Plugin stack builder Cost calculator Salt generator Theme detector Who is hosting this? Speed test Headline analyzer robots.txt generator Redirect generator Uptime calculator Blog name generator
Best lists Best backup plugins Deals
Guides All guides Speed up WordPress Choose hosting Back up WordPress
How we test

Speed & performance · Guide

How to Fix "Avoid Enormous Network Payloads" in WordPress

Short answer

To fix “Avoid enormous network payloads” in WordPress, find the largest files in Lighthouse, then shrink images, defer scripts and embeds below the first screen, turn on Brotli or Gzip compression, and remove third-party code you do not need. Aim for a total page size below 1,600 KiB and recheck the page after each change.

Key takeaways

  • Lighthouse flags pages whose total network requests exceed 5,000 KiB, and Google advises aiming below 1,600 KiB.
  • The median network payload is between 1,700 and 1,900 KiB, based on HTTP Archive data cited by Chrome for Developers.
  • WebP often compresses better than JPEG, PNG or GIF, and AVIF has shown greater than 50% savings over JPEG in some cases.
  • Lazy loading a YouTube embed saves more than 500 KiB during the first page load, according to web.dev.
  • Brotli was 14% smaller than Gzip for JavaScript, 21% smaller for HTML and 17% smaller for CSS in a web.dev example.
  • Lighthouse flags every JavaScript file with more than 20 KiB of unused code.

What does “Avoid enormous network payloads” mean in WordPress?

It means the total size of everything a page downloads is large enough to slow loading and use extra mobile data.

A network payload is the combined transfer size of HTML, CSS, JavaScript, images, fonts, video files and third-party requests for one page. Lighthouse adds up those requests and lists the largest ones first, so you can see which files drive the total.

Chrome for Developers states that large network payloads are highly correlated with long load times and that they also cost users money, for example when visitors pay for cellular data. That link is the reason this warning matters even when a page looks fine on a fast office connection.

How big is too big for a WordPress page?

Aim for a total below 1,600 KiB, and treat anything above 5,000 KiB as a clear problem.

Chrome for Developers reports that the median network payload is between 1,700 and 1,900 KiB, based on HTTP Archive data. Lighthouse flags pages whose total network requests exceed 5,000 KiB.

The 1,600 KiB target comes from the amount of data that can be downloaded on a 3G connection while still reaching Time to Interactive in 10 seconds or less, according to the same Lighthouse total byte weight page. That target is a guide, not a pass mark for every page type.

Page totalWhat it meansNext step
Below 1,600 KiBInside the Lighthouse targetKeep the budget and recheck after each change
1,700 to 1,900 KiBNear the median payloadFind the 3 largest files first
Above 5,000 KiBLighthouse flags the pageCut images, scripts or embeds before anything else

A shop page with many product photos may sit above a short text page, so set one budget per page type. A single site-wide number hides that difference and leads to the wrong fixes.

How do you find the files that make a page heavy?

Run Lighthouse on the page, open the “Avoid enormous network payloads” audit and sort its list by size.

Use PageSpeed Insights or Lighthouse in Chrome DevTools, then read the audit list from the largest request down. The top 3 or 4 files often hold most of the weight, so start there instead of changing settings at random.

Then open Chrome DevTools, go to the “Network” tab, tick “Disable cache” and reload the page. Sort by size and filter by type, such as image, script or font, to confirm which kind of file is heaviest.

Write down 3 numbers for each page you fix: total transfer size, the largest file and its type, and the count of requests. Repeat the same check after each fix, with the cache disabled, so the before and after numbers use the same method.

For a wider view of speed work on your site, see how to speed up WordPress.

How do you shrink images without losing quality?

Serve each image at the size its slot needs, in WebP or AVIF where you can, and compress it before upload.

Images are often the heaviest part of a WordPress page, so fix them before you touch code. Upload a 4,000-pixel photo for a 800-pixel slot and the browser still downloads the large file.

Follow these steps for each heavy image:

  1. Resize the file to the largest size the layout shows, plus a small margin for sharp screens.
  2. Save photos as WebP or AVIF and keep JPEG or PNG only as a fallback where a format is not supported.
  3. Compress the file with an image tool or plugin, then check that text and faces still look clean.
  4. Replace the old file in the Media Library and update the page if the theme still points at the old size.

WebP often has better compression than JPEG, PNG or GIF, and it supports both lossy and lossless compression, according to the web.dev image performance guide. The same guide reports that AVIF has shown greater than 50% savings compared with JPEG in some cases.

WordPress adds responsive srcset markup for uploaded images, so the browser can pick a smaller file on a small screen. That helps only if you upload a sensibly sized original and your theme uses the sizes WordPress generates.

How do you cut JavaScript and CSS weight in WordPress?

Remove plugins and features you do not use, load scripts only on the pages that need them, and minify what is left.

Every active plugin can add CSS and JavaScript to pages where it is never used. A contact form script on every page, a slider library on a text page and a map script on a page with no map all add weight for no gain.

Start with this audit:

  • List active plugins under “Plugins → Installed Plugins” and deactivate each one you cannot name a job for.
  • Check whether a plugin has a setting to load its assets only on chosen pages or post types.
  • Remove unused page-builder widgets, blocks and font weights from the pages that load them.
  • Ask your theme or plugin author how to stop an asset loading on a page, rather than editing theme files by hand.

Lighthouse flags every JavaScript file with more than 20 KiB of unused code, according to the Chrome for Developers unused JavaScript page. That 20 KiB line is a useful place to start when you sort the Lighthouse list.

Minify CSS and JavaScript to remove spaces, comments and line breaks that browsers do not need. Most caching plugins offer a minify setting; turn it on, clear the cache and check that menus, forms and sliders still work.

If you use WP Rocket, follow how to configure WP Rocket for Core Web Vitals for its file optimisation settings.

If you use LiteSpeed Cache, see how to set up LiteSpeed Cache with QUIC.cloud.

How do you defer scripts and embeds until they are needed?

Load below-the-fold images and iframes lazily, and defer scripts that the first screen does not need.

Lazy loading holds back a file until the visitor scrolls near it. That cuts the first load, because files nobody scrolls to may never download at all.

WordPress adds loading="lazy" to images in post content by default, and it adds fetchpriority="high" to the first large image in WordPress 6.3 when that image is at least 50,000 square pixels, according to the WordPress developer news for July 2023. Do not lazy-load the hero image yourself, because that delays the largest visible element.

For scripts, WordPress supports defer and async loading strategies through wp_enqueue_script(), as shown in the WordPress developer reference for wp_enqueue_script. A deferred script runs after the document is parsed, while an async script runs as soon as it loads, with no fixed order between scripts.

Use these rules for embeds:

  1. Add loading="lazy" to iframes below the first screen, such as maps and video players.
  2. Replace a video embed with a still image and a play button when most visitors never press play.
  3. Load chat widgets, social feeds and review widgets after the first screen, or on click where the tool allows it.

Web.dev reports that lazy loading a YouTube video embed saves more than 500 KiB during the first page load, in its guide to lazy loading images and iframes. That one change can move a page from flagged to near the target.

How do you use compression and caching to send fewer bytes?

Turn on Brotli or Gzip compression for text files, minify them first, and cache repeat visits so the browser reuses files.

Compression shrinks HTML, CSS and JavaScript before they travel over the network, and the browser expands them on arrival. It does not shrink images or video, which are already compressed, so do not expect it to fix a 3 MB photo.

Web.dev reports Brotli results of 14% smaller than Gzip for JavaScript, 21% smaller for HTML and 17% smaller for CSS, in its Brotli text compression guide. In the same guide, a sample bundle fell from 225 KB to 53.1 KB with Brotli, against 61.6 KB with Gzip.

Cloudflare states that Brotli is its preferred compression algorithm and that it falls back to Gzip or uncompressed data when needed, in its Compression Rules settings. Compression Rules are available in all Cloudflare plans, according to the Cloudflare Compression Rules page.

Check compression in 5 minutes:

  1. Open Chrome DevTools, go to the “Network” tab and reload the page.
  2. Click a CSS or JavaScript file and look at its response headers for content-encoding: br or content-encoding: gzip.
  3. Compare the transfer size with the file size to confirm the saving.
  4. If no header appears, ask your host to enable Brotli or Gzip, or turn it on in your CDN settings.

Caching is the second half of the fix. A cached file is reused on a repeat visit instead of being downloaded again.

That is why the Lighthouse page lists caching as a way to keep payload size down. Set cache rules for static files in your caching plugin or CDN, then test a repeat visit with the cache left on.

For cache settings at the CDN level, see Cloudflare cache rules for WordPress.

How do you trim third-party scripts, fonts and videos?

List every script that comes from another domain, keep only the ones with a clear job, and delay or remove the rest.

Third-party code is easy to add and hard to see. Analytics, ads, chat tools, social buttons, font services and video players each add requests, and each one can pull in more files of its own.

Audit them in this order:

  • Open the Lighthouse list and note each file whose domain is not yours.
  • For each one, write down its job, who asked for it and what breaks if it goes.
  • Remove duplicates, such as 2 analytics tools or 2 chat widgets doing the same job.
  • Delay what is left until after the first screen, where the tool allows a delay.

Fonts need the same care. Each weight and style is a separate file, so a font family with 4 weights and italics can mean 8 downloads. Keep 2 weights at most for body text, use a system font for small labels where you can, and host the font files yourself if your theme allows it.

Video is the heaviest item of all. Host a short clip as a file only when it must play on the page, and use a still image with a play button for longer videos. A background video that plays on every visit adds weight to every page view, even for visitors who never watch it.

How do you set a payload budget and keep it?

Write down a size limit for each page type, check it after every change, and fix the page when a new file breaks it.

A performance budget is a set of limits on numbers that affect speed, such as page weight, script size or request count. Web.dev defines it that way and groups budget numbers into quantity limits, milestone timings and rule-based scores, in its Performance Budgets 101 guide.

Use the sample limits in that guide as a starting point: under 5 seconds to interactive and under 170 KB of critical-path resources, compressed and minified, on a slow mobile network. Those numbers describe the first load, not the whole page, so pair them with your own total-page limit from the table above.

Set your budget in 4 steps:

  1. Record the current total for your home page, a typical post and a typical product or landing page.
  2. Set a total limit for each type, starting near the Lighthouse 1,600 KiB target for posts.
  3. Add a per-file limit, such as no single image above 200 KB and no single script above 100 KB.
  4. Recheck the 3 page types after each plugin install, theme change or new embed.

Splitting a JavaScript bundle so a page loads only the code its first screen needs is one way to stay inside a budget. Web.dev notes that sending less JavaScript at startup helps Interaction to Next Paint, in its guide to code splitting.

For help with the interaction side of that work, see what is INP.

What mistakes should you avoid?

Do not chase the warning by adding a second optimisation plugin, lazy-loading the hero image, or compressing images that are already compressed.

These errors are common, and each one can make a page slower while the total looks smaller on paper.

  • Adding 2 caching or minify plugins at once can break scripts, double-process files and hide the real cause.
  • Lazy-loading the hero image delays the largest visible element and hurts Largest Contentful Paint.
  • Setting “Blog pages show at most” to a high number loads many posts, images and scripts on one archive page.
  • Showing full posts instead of excerpts on archive pages has the same effect, which is why the Lighthouse WordPress guidance suggests excerpts, fewer posts per page and splitting long posts.
  • Turning on compression and then skipping the header check leaves you guessing whether it works.
  • Removing a script by name without checking what it does can break a form, a menu or checkout.

If you use a page builder, check its own performance settings before adding another plugin. See how to speed up Elementor for the settings that matter most there.

Fix the largest files first, recheck with the same method, and stop when the page sits inside its budget. A page that stays under its limit after each new post or plugin is fixed; a page that needs a fresh cleanup every month is not.

Frequently asked questions

What is a good total page size for WordPress?

Aim for a total below 1,600 KiB, which is the target Google gives in its Lighthouse guidance. The median page sits between 1,700 and 1,900 KiB, and Lighthouse flags pages above 5,000 KiB. Set a separate limit for each page type, because a shop page with product photos will weigh more than a short text page.

Does lazy loading fix enormous network payloads?

It helps with the first load, because images and iframes below the first screen do not download until the visitor scrolls near them. It does not make any file smaller, and it does not help if the hero image or the first screen is the heavy part. Keep the hero image eager and lazy-load only what sits below it.

Will a caching plugin alone remove this warning?

No. Caching helps repeat visits by reusing files, but the first visit still downloads the full payload. You still need to shrink images, cut unused JavaScript and CSS, defer embeds and turn on compression. Use caching as the last step, after the files themselves are smaller.

Should I remove all third-party scripts to pass the audit?

No. Keep the tools your site needs, such as analytics or a payment form, and remove duplicates and tools nobody uses. Delay chat widgets, social feeds and video embeds until after the first screen where the tool allows it. Removing a script without checking what it does can break a form, a menu or checkout.

How often should I recheck page weight?

Recheck after every plugin install, theme change, new embed or large image upload, and at least once a month for your busiest pages. Use the same method each time, with the cache disabled in DevTools, so the numbers stay comparable. A page that stays inside its budget after changes is fixed.

Sources

  1. Avoid enormous network payloads Chrome for Developers
  2. Image performance web.dev
  3. Lazy load images and iframe elements web.dev
  4. Minify and compress network payloads with Brotli web.dev
  5. Performance budgets 101 web.dev
  6. Compression Rules settings Cloudflare Developers
  7. wp_get_loading_optimization_attributes() WordPress Developer Resources
  8. Reduce unused JavaScript Chrome for Developers

Is your product missing, or something out of date?

Tell us what to add or correct. We read every note and reply when we need a source. A message does not buy a ranking.

About the editors

WPLegible editors

Researched from the primary sources listed above and checked against our editorial rules. About the site · How we test