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 Improve INP in WordPress

Short answer

To improve INP in WordPress, find the slowest interaction in PageSpeed Insights field data, reproduce it in Chrome DevTools, and fix the phase that causes the delay. Cut long JavaScript tasks over 50 milliseconds, delay non-critical scripts until a visitor interacts, shrink the rendering work after each click, and then wait for new 28-day field data to confirm the change.

Key takeaways

  • A good INP is 200 milliseconds or less, needs improvement up to 500 milliseconds, and is poor above 500 milliseconds at the 75th percentile.
  • INP counts only clicks, taps, and key presses, and it looks at interactions across the whole visit, not just the first one.
  • A long task is any main-thread task over 50 milliseconds, and it can block the browser from answering a click or tap.
  • INP has 3 parts: input delay, processing duration, and presentation delay, and each part needs a different fix.
  • PageSpeed Insights field data covers the previous 28 days, so a fix takes weeks to show as a pass in field data.
  • WordPress 6.8 turns on speculative loading by default for logged-out visitors on sites with pretty permalinks.

What is INP and what counts as good?

A good INP is 200 milliseconds or less, needs improvement up to 500 milliseconds, and is poor above 500 milliseconds, measured at the 75th percentile of page loads.

Interaction to Next Paint, or INP, is a metric that assesses how quickly a page responds to clicks, taps, and key presses during a visit. The INP guide on web.dev defines it as observing the latency of all click, tap, and keyboard interactions across the lifespan of a visit.

Only 3 interaction types count: clicking with a mouse, tapping on a touchscreen, and pressing a key. Scrolling and hovering do not count, so a slow scroll does not change your INP score.

Chrome usage data cited by web.dev shows that 90% of a user's time on a page is spent after it loads. That is why INP looks at the whole visit, not just the first click, and why a slow menu late in a visit can set the score.

INP is the successor to First Input Delay, which measured only the first interaction. INP looks at all interactions, and web.dev says the final value is the longest interaction observed, ignoring outliers.

INP resultRatingWhat it means
200 milliseconds or lessGoodMost interactions feel instant
Over 200 up to 500 millisecondsNeeds improvementVisitors notice a lag after taps
Over 500 millisecondsPoorTaps feel ignored and visitors tap again

How do you find your WordPress site's INP score?

Open PageSpeed Insights, enter your page URL, and read the INP value in the field data section.

PageSpeed Insights shows both field data and lab data for a page. The About PageSpeed Insights page says field data comes from the Chrome User Experience Report, known as CrUX, and covers the previous 28-day collection period.

Field data is the score that matters for INP, because it comes from real visitors on real devices. Lab data is a simulated load in a controlled setting, and it may not show the slow interaction your visitors hit.

Check mobile and desktop separately, because web.dev says the 75th percentile is measured for each device type. A page can pass on desktop and fail on mobile, where phones have less processing power.

If a page has too little traffic, PageSpeed Insights may show origin-level data instead of URL-level data. That still tells you whether the site has an INP problem, but it will not name the exact page.

If the terms still feel new, read what INP is before you change any settings on your site.

Which interaction is slowing your site down?

Start with the slowest interaction named in your field data, then reproduce that exact click, tap, or key press in Chrome DevTools.

Do not start by guessing which plugin is slow. Field data from a Real User Monitoring tool can name the interaction, the page, and whether it happened during or after page load, according to the optimize INP guide on web.dev.

In DevTools, open the Performance panel, start a recording, perform the slow interaction once, and stop the recording. The Interactions track splits the interaction into its 3 parts, so you can see which part took the longest.

INP partWhat it measuresMain clue
Input delayTime from the input until event handlers startMain thread was busy with other work
Processing durationTime the event handlers take to runThe handler itself is heavy
Presentation delayTime from the end of the handlers until the next frame paintsRendering work after the click is heavy

Chrome's INP breakdown insight gives the same split in the Performance panel. The Chrome INP breakdown page says a high input delay points to other main-thread work, a high processing duration points to the event handlers, and a high presentation delay points to a rendering delay.

How do you cut input delay on WordPress?

Reduce the JavaScript that runs while the page loads, so the main thread is free when a visitor clicks.

Input delay grows when scripts are still loading, parsing, and compiling while a visitor tries to interact. Web.dev says script evaluation can create long tasks on the main thread, and those tasks delay the browser from responding to other user interactions.

A long task is any task over 50 milliseconds on the main thread. The long tasks guide on web.dev says the main thread can only process one task at a time, so a click that arrives during a long task must wait for that task to finish.

Work through this list on the pages with the worst INP:

  1. Remove plugins that add JavaScript to every page but are used on only 1 page.
  2. Turn off chat widgets, popups, and extra trackers on pages where they are not needed.
  3. Delay third-party scripts until after the first paint, or until a visitor interacts.
  4. Keep only 1 caching and optimization plugin active, so 2 plugins do not fight over the same scripts.

A current PHP version also helps the server answer faster. See which PHP version to use for WordPress before you change the PHP version on a live site.

How do you shorten slow event handlers?

Do only the work needed for the next paint inside the handler, and move the rest to a later task.

Web.dev gives a clear rule for event callbacks: do as little work as possible in them. If the logic is complex, break the work into separate tasks so the browser can paint sooner and handle the next input.

Use this order inside a handler that does several jobs:

  1. Update the visible result first, such as opening the menu or showing the typed text.
  2. Yield to the main thread, so rendering can run before the next frame.
  3. Run the remaining work after the paint, such as saving data or updating a word count.

Web.dev shows the same pattern with a text editor: only updating the text box needs to happen before the next frame, while updating the word count, checking spelling, and saving can wait. The optimize INP guide says setTimeout is one way to break up tasks, because its callback runs in a new task.

Avoid layout thrashing in handlers. That happens when code updates styles in JavaScript and then reads those styles back in the same task, which forces the browser to do layout work at once instead of later.

How do you reduce presentation delay after a click?

Shrink the rendering work after the handler finishes, so the browser can paint the next frame sooner.

Presentation delay runs from the end of the event handlers until the browser paints the next frame. Web.dev says large DOMs make rendering updates more expensive, so a click that changes a large page takes longer to show.

Try these changes in order:

  • Cut the DOM size on the worst pages by removing hidden sliders, extra widgets, and repeated blocks.
  • Flatten nested layouts where you can, instead of stacking containers inside containers.
  • Add content to the DOM during the interaction, rather than loading it all on the first page load.
  • Use the CSS content-visibility property to lazily render off-screen elements as they approach the viewport.

Web.dev notes that content-visibility can take practice to use well, but it can lower rendering time for both page load and interactions. Check the page after each change, because a layout that renders late can shift content on screen.

How do you delay JavaScript without breaking menus and forms?

Turn on Delay JavaScript Execution in WP Rocket, then exclude any script that breaks a menu, form, or slider.

WP Rocket's docs say Delay JavaScript Execution delays all JavaScript files and inline scripts until a user interaction, such as moving the mouse, touching the screen, scrolling, or pressing a key. You will find the setting on the File Optimization tab in WP Rocket.

Follow these steps:

  1. Go to Settings, then WP Rocket, then File Optimization in your WordPress admin.
  2. Under JavaScript Files, turn on Delay JavaScript Execution and save changes.
  3. Open your menu, search box, cart, and forms on a test page and click each one.
  4. If an item only appears after you move the mouse, add its script to the Excluded JavaScript Files box.

WP Rocket notes that the Combine JavaScript files feature is disabled when you use Delay JavaScript Execution, so scripts load in the correct order. If a fix needs a wider reset, use the Safe Mode for Delay JavaScript Execution option described in the Delay JavaScript Execution docs.

For the full caching setup around this setting, see how to configure WP Rocket for Core Web Vitals.

What should you change in your theme and plugins first?

Audit the theme and plugins that add JavaScript to every page, and remove or replace the heaviest ones first.

Start with the items that run on every page, because they add input delay to every interaction. A slider on the home page is less urgent than a chat script that loads on every post.

Common culpritWhat to checkFirst fix
Page builderExtra scripts on pages that do not use its widgetsUse the builder only where it is needed
Chat widgetScript loads on every pageLoad it only on contact and sales pages
Search and filtersHandler runs on every key pressAdd a short pause before the search runs
Social feedsThird-party scripts load at onceLoad the feed after the main content
Cookie bannerScript blocks the first paintDelay it until after the first interaction

If you use Elementor, check its performance settings before you add another plugin. See how to speed up Elementor for the settings that cut its script load.

Deactivate 1 plugin at a time and repeat the slow interaction in DevTools after each change. That way you can link a change in INP to the plugin you just changed.

How does speculative loading help INP in WordPress?

Leave WordPress 6.8 speculative loading on for logged-out visitors, so the next page is partly ready before the click.

WordPress 6.8 added speculative loading to core. The speculation rules hook in WordPress Developer Resources says the mode can be prefetch or prerender, and the eagerness can be eager, moderate, or conservative.

By default, speculative loading is only enabled for sites with pretty permalinks when no user is logged in. That limit keeps logged-in admin work and plain permalink URLs out of the feature.

The default mode and eagerness are both set to auto, which lets WordPress Core decide the configuration. A developer can force a mode or eagerness with the wp_speculation_rules_configuration filter, or return null to disable speculative loading for that request.

WordPress always excludes paths such as /wp-login.php and /wp-admin/* from speculative loading. You can exclude more paths, such as checkout or account pages, with the wp_speculation_rules_href_exclude_paths filter.

Speculative loading helps the next navigation, not the click on the current page. For the full setup, read what speculative loading is in WordPress.

How do you check that your INP fix worked?

Reproduce the same interaction in DevTools, then wait for new 28-day field data before you call the fix a pass.

A lab recording can show that a long task is gone, but it cannot prove that real visitors now see a good INP. Web.dev says lab tools may not report INP at all when they only load a page without interactions.

Total Blocking Time can act as a lab proxy for INP, but web.dev says it is not a substitute for INP itself. Use it to spot long tasks in the lab, then confirm the result in field data.

Follow this check list after each fix:

  1. Record the same interaction in DevTools and confirm the longest part is shorter.
  2. Run PageSpeed Insights again and note the lab result, not the field result.
  3. Wait for the 28-day CrUX window to roll forward, then check the field INP value.
  4. Check the Core Web Vitals report in Search Console to see if the page group moved.

Fix 1 interaction at a time and record the result. If you change 5 things at once, you will not know which change helped.

What mistakes should you avoid?

Avoid chasing a lab score, delaying scripts your menus need, and changing 5 things at once.

A lab score can look good while real visitors still hit a slow interaction that the lab run never performed. Field data is the check that counts, and it needs time to update.

Do not delay scripts that run your menu, cart, or forms without an exclusion. A delayed menu script can make the menu open only after a mouse move, which feels worse than a slow INP score.

Do not fix the average interaction and ignore the worst one. Web.dev says the final INP value is the longest interaction observed, ignoring outliers, so 1 slow button can set the score for the page.

Do not test only on a fast desktop. Mobile visitors use slower devices, and web.dev measures the 75th percentile separately for mobile and desktop.

Do not remove a plugin and a theme feature on the same day. Change 1 item, repeat the interaction, and write down what changed before you move on.

Frequently asked questions

How long does it take for an INP fix to show in PageSpeed Insights?

Field data covers the previous 28 days, so a fix does not show as a pass right away. The lab result can change on the next run, but the field INP value moves only as older visits leave the 28-day window. Check the field value again after 2 to 4 weeks, and use the Search Console Core Web Vitals report to see if the page group moved.

Can I improve INP without writing code?

Yes, in many cases. Remove plugins that add JavaScript to every page, delay non-critical scripts with a caching plugin, and turn off chat widgets or popups where they are not needed. Those changes cut the long tasks that block clicks. If the slow part is inside a theme or plugin handler, a developer may still need to split that handler into smaller tasks.

Why is my INP good on desktop but poor on mobile?

Mobile phones have less processing power, so the same JavaScript task takes longer on a phone than on a desktop. Web.dev measures the 75th percentile separately for mobile and desktop, so a page can pass on one and fail on the other. Test the slow interaction with CPU throttling in DevTools to see how it behaves on a weaker device.

Does delaying JavaScript always improve INP?

No. Delaying scripts can free the main thread during page load, which helps input delay, but it can also break menus, forms, and sliders that need their scripts at once. If an item only appears after you move the mouse, exclude its script from the delay. Test every menu, form, and cart flow after you turn the setting on.

What is the difference between INP and Total Blocking Time?

INP measures real interactions from click to next paint, while Total Blocking Time is a lab metric that adds up the blocking part of long tasks during page load. Web.dev says Total Blocking Time can act as a proxy for INP in the lab, but it is not a substitute. A page can have low blocking time in the lab and still have a slow interaction in the field.

Should I turn off speculative loading if my INP is poor?

No, leave it on unless it causes a clear problem. Speculative loading in WordPress 6.8 prepares the next page before the click, which can help the next navigation feel faster. It does not fix a slow handler on the current page, so fix the long tasks and heavy handlers first, and only exclude checkout or account paths if they cause trouble.

Sources

  1. Interaction to Next Paint (INP) web.dev
  2. Optimize Interaction to Next Paint web.dev
  3. Optimize long tasks web.dev
  4. About PageSpeed Insights Google for Developers
  5. wp_speculation_rules_configuration WordPress Developer Resources
  6. Delay JavaScript execution WP Rocket
  7. INP breakdown 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