How to Fix Poor INP in WordPress (Interaction to Next Paint)

Fix INP in WordPress step by step: find the slow click in Chrome DevTools, delay third-party scripts, unload plugin JS, slim Elementor and verify the result.

To fix INP in WordPress, free up the browser’s main thread at the moment a visitor clicks, taps or types. Google rates Interaction to Next Paint as good at 200 milliseconds or less, and poor above 500 ms.

The usual culprits are chat widgets, tag managers, plugin scripts loaded everywhere and heavy builder markup. Below is the order to fix them in, and the checks that prove each fix worked.

⚡ Quick answer

  • Best for: WordPress sites where PageSpeed Insights or Search Console shows INP as Needs improvement (over 200 ms) or Poor (over 500 ms) on mobile.
  • Skip if: your field INP is already under 200 ms at the 75th percentile. A red Total Blocking Time in a lab test alone is not an INP failure.
  • Time needed: one to three hours to find and fix the worst interaction, then up to 28 days for field data to catch up.
  • Our call: cut third-party JavaScript first, unload plugin scripts per page second, and only then touch theme or builder markup.

What is INP and what is a good INP score?

Interaction to Next Paint measures the delay between a user action and the next frame the browser paints in response. It replaced First Input Delay as a Core Web Vital on 12 March 2024.

INP watches every click, tap and key press during a visit. Hovering, scrolling and zooming are not counted. The reported value is roughly the worst interaction, with one outlier ignored for every 50 interactions on busy pages.

INP thresholds bar showing Good up to 200 milliseconds, Needs improvement up to 500 milliseconds and Poor above 500 milliseconds
INP thresholds: good at 200 ms or less, poor above 500 ms. Source: web.dev, captured November 2026.
INP at the 75th percentileRatingWhat it means for a WordPress site
0–200 msGoodMenus, accordions and forms respond on the next frame for most visitors
201–500 msNeeds improvementTaps feel sticky on mid-range phones; usually one or two heavy scripts
Over 500 msPoorVisitors tap twice, menus open and close, forms feel broken
Thresholds from web.dev and the PageSpeed Insights documentation, checked November 2026. Measured on mobile and desktop separately.

Every interaction has three parts, and the fix depends on which part is slow. Learn these three names; the rest of this guide uses them.

Diagram of one interaction split into input delay, processing duration and presentation delay before the frame is presented
Input delay, processing duration and presentation delay make up one interaction. Source: web.dev, captured November 2026.
  • Input delay: the click waits because the main thread is busy with something else, often a script still loading or a third-party timer.
  • Processing duration: the event handlers themselves run too long, such as a menu script or an analytics click listener.
  • Presentation delay: the browser needs too long to recalculate styles and repaint, usually because the page’s DOM is huge.

If you need the wider picture with LCP and CLS, start with our guide on how to pass Core Web Vitals in WordPress. This article goes deep on INP only.

What you need before you start

  • A public URL with traffic. Field INP comes from real Chrome visits. A brand-new page has no data yet.
  • Chrome on a desktop. DevTools ships with it; no extension needed.
  • Administrator access to install or configure a performance plugin, plus FTP or a snippets plugin for code changes.
  • A staging copy or a fresh backup. Delaying and unloading scripts is the most common way to break a menu or a form.
  • WordPress 6.3 or later if you want to use the core defer strategy shown in Step 4.

New to speed work? Read our complete guide to speeding up a WordPress website first. Caching and hosting fix LCP; INP needs the JavaScript work below.

Common mistake: testing only the homepage. INP failures in Search Console usually come from a template, such as single posts with a chat bubble or product pages with a gallery.

Step 1: Confirm the INP problem in field data

Start with real-user data, not a lab score. Open PageSpeed Insights, paste the failing URL and read the top section about real users. That block is CrUX field data from the last 28 days.

If the URL has too little traffic, PageSpeed Insights falls back to origin-level data for the whole domain. In Search Console, the Core Web Vitals report groups failing URLs by template, which tells you where to look.

To see whether INP is getting better or worse over time, open CrUX Vis and switch to Interactivity. The chart below shows a real origin, wordpress.org, holding its phone INP inside the good band through 2026.

CrUX Vis Interaction to Next Paint chart for the wordpress.org origin on phones, 75th percentile staying below 200 milliseconds from January to November 2026
INP at the 75th percentile for the wordpress.org origin on phones. Source: CrUX Vis (cruxvis.withgoogle.com), captured November 2026.

Do this if: INP is Needs improvement or Poor on mobile. Skip ahead if: only the lab report complains. Lighthouse never clicks, so it shows Total Blocking Time as a proxy, not INP.

Step 2: Find the slow interaction in Chrome DevTools

Field data tells you that a page is slow. DevTools tells you which click and why. Open the page in Chrome, press F12, and choose the Performance tab.

  1. In the capture settings, set CPU throttling to 4× slowdown. Your laptop is faster than your visitors’ phones; throttling makes the slow click show up.
  2. Reload the page and interact the way visitors do: open the mobile menu, expand an accordion, tap a tab, type in search.
  3. Watch the live INP card update after each interaction. The Interactions list shows which element was slowest.
  4. Click Record, repeat that one slow interaction, then stop the recording.
  5. Open Insights → INP breakdown. It zooms to the interaction and shows the three phases in milliseconds.
Chrome DevTools Performance panel with the INP breakdown insight showing a 267 ms interaction split into 76 ms input delay, 136 ms processing duration and 55 ms presentation delay
A click traced with 4× CPU slowdown: 267 ms INP, mostly processing time. Recorded on web.dev’s public INP article in Chrome DevTools, November 2026.

In that trace, processing is the biggest phase, and the Summary tab lists Google Tag Manager with 130 ms of main-thread time in the same window.

That shape is common on content sites: the page’s own code is light, and the tags are not.

Biggest phaseUsual WordPress causeGo to
Input delayScripts still loading or running when the visitor taps: chat, ads, tag managers, slidersStep 3 and Step 4
Processing durationHeavy click handlers: analytics listeners, menu or popup scripts, jQuery pluginsStep 3 and Step 6
Presentation delayA deep DOM from nested builder sections, mega menus, large comment threadsStep 5 and Step 6
Phase-to-cause mapping based on web.dev’s INP optimisation guides, checked November 2026.

The catch: one recording on your laptop is a sample, not a verdict. Repeat the interaction three times and fix the phase that is consistently largest.

Step 3: Cut and delay third-party JavaScript

Third-party scripts are the cheapest INP win, because you rarely need them on every page or at load time. In your trace, the Summary and Bottom-up tabs show which third parties use the main thread.

Remove what nobody uses

Audit your tag manager container and header scripts. Old A/B tests, retired ad pixels and duplicate analytics tags cost main-thread time on every visit. Delete them before you optimise them.

Put chat and video behind a facade

A facade is a static placeholder that looks like the widget and loads the real script only when someone clicks it. Chrome’s Lighthouse documentation on third-party facades recommends the pattern for chat widgets and video embeds.

Chat is the usual offender. Our roundup of WordPress live chat plugins covers which widgets let you load chat only on pages where someone answers it.

For YouTube, the lazy load plugins that swap YouTube embeds for a preview thumbnail do the facade work for you.

Delay the rest until the first interaction

Performance plugins can hold scripts back until the visitor scrolls, moves the mouse or taps. Perfmatters calls it Delay JavaScript, with two modes: specified scripts or all scripts. Our Perfmatters review walks through its settings.

If you would rather keep one plugin, several options in our comparison of WordPress cache plugins include a delayed JavaScript setting alongside page caching.

⚠️ The catch: delaying everything moves the cost to the first tap. If the menu script is delayed, that tap loads every held-back script before the menu opens. Exclude menu, form and slider scripts; delay tags, chat and pixels.

Our pick: use “delay specified scripts” with a short list (analytics, tag manager, ad and social pixels) rather than “delay all”. It is less dramatic in a lab score and much safer for real INP.

Step 4: Load plugin scripts only where they are used

A form plugin that loads its JavaScript on every post adds parse and compile work to pages without a form. Unloading it there is how you reduce JavaScript in WordPress without losing features.

Script managers such as the one in Perfmatters let you switch a plugin’s assets off per page, post type or URL. Start with forms, sliders, galleries and pop-ups, then re-test the pages you changed.

If you build your own theme or plugin, WordPress 6.3 added a loading strategy to the Scripts API. The core dev note on async and defer in WordPress 6.3 documents a strategy argument:

add_action( 'wp_enqueue_scripts', function () {
	wp_enqueue_script(
		'my-menu',
		get_stylesheet_directory_uri() . '/js/menu.js',
		array(),
		'1.0.0',
		array(
			'in_footer' => true,
			'strategy'  => 'defer',
		)
	);
} );

Put code like this in a child theme’s functions.php, or in one of the WordPress code snippet plugins so it survives theme updates.

Common mistake: expecting defer to stick everywhere. Per the dev note, a script with an inline script attached after it stays blocking. So does a deferred script with a blocking dependent; WordPress protects execution order.

Skip it if: you only run third-party themes and plugins. Changing their registrations from outside is fragile; use a script manager instead.

Step 5: Fix INP on Elementor sites

Page builders add two INP costs: more JavaScript per page and a deeper DOM. Elementor has addressed both in core, so first make sure you are not running an old configuration.

  • Improved Asset Loading: per Elementor’s help article on Improved Asset Loading, libraries such as the lightbox (about 20 KB), dialog (11 KB) and share links (3 KB) load only on pages that use them.
  • Optimized DOM Output: Elementor removed several wrapper divs, and from version 3.19 that leaner markup is part of core rather than an option.
  • Containers instead of sections and columns: a section needs a column inside it, a container does not, so the same layout produces fewer nested wrappers.

Then check the DOM. In the Console, run document.querySelectorAll('*').length. Lighthouse starts warning above 800 nodes and calls a DOM excessive above 1,400. Mega menus and nested tabs are the usual bloat.

Addons matter more than Elementor itself. Every extra widget pack adds handlers and styles, so prune the ones you no longer use; our guide to the best Elementor addons flags which suites let you disable unused widgets.

Elementor’s V4 editor outputs leaner atomic elements, explained in our Elementor V4 guide to atomic elements, classes and variables. Before switching an old site, follow our step-by-step Elementor V3 to V4 migration checklist on staging.

The catch: Element Caching speeds up server rendering and TTFB, not the browser’s main thread. It helps LCP; do not expect it to move INP.

Step 6: Break up long tasks in your own code

If the slow handler is your own code, the fix is to do less before the next paint. Any task over 50 ms counts as a long task and blocks input.

Update the screen first, then yield and do the rest in a new task. The web.dev guide to optimizing long tasks recommends scheduler.yield() with a fallback, because Safari does not support it yet:

function yieldToMain() {
	if ( globalThis.scheduler?.yield ) {
		return scheduler.yield();
	}
	return new Promise( ( resolve ) => setTimeout( resolve, 0 ) );
}

button.addEventListener( 'click', async () => {
	menu.classList.toggle( 'is-open' ); // visible change first
	await yieldToMain();
	sendAnalytics();                      // background work after the paint
} );

Yield after the visible change, never before it.

For presentation delay on long pages, content-visibility: auto lets the browser skip rendering off-screen sections until they near the viewport. Our guide to adding custom CSS in WordPress and Elementor shows where to put it.

Do this if: DevTools shows your theme or plugin file at the top of the processing bar. Skip it if: the time belongs to third parties; Step 3 is faster.

How do you check the INP fix worked?

  • Lab check, same day: repeat the exact interaction in the DevTools Performance panel with the same 4× slowdown. The INP breakdown should show the phase you targeted shrinking.
  • Functional check: open the menu, submit a form and play a video on mobile. A faster INP with a dead menu is not a fix.
  • Field check, after 28 days: PageSpeed Insights uses a rolling 28-day window, so expect a gradual slide rather than an overnight change.
  • Search Console: once field data looks good, open the failing issue in the Core Web Vitals report and click Validate fix.

Want real-user INP sooner? The open-source web-vitals library reports INP with attribution from your visitors. web.dev’s INP documentation explains why field data beats a lab trace for this metric.

What breaks and how to undo it

SymptomLikely causeFix
Mobile menu needs two tapsMenu script is delayed until interactionExclude the theme’s menu script from delay
Form will not submit or captcha missingForm or captcha script unloaded or delayedRe-enable the form plugin’s assets on that page; exclude its script
Analytics sessions dropTag manager delayed with no timeoutEnable the plugin’s delay timeout, or accept that bounced bots disappear
Slider or gallery shows unstyledSwiper or lightbox script unloaded on a page that uses itRemove that page from the script manager rule
INP worse after enabling delay allEvery held-back script runs on the first tapSwitch to delaying specified scripts only
Symptoms compiled from Perfmatters’ delay JavaScript documentation and the WordPress 6.3 Scripts API dev note, checked November 2026.

To undo, change one setting at a time and keep a note of what you changed. Turning off the last change is faster than restoring a backup, and it tells you exactly which script mattered.

Frequently Asked Questions

What is a good INP score for WordPress?

A good INP is 200 milliseconds or less at the 75th percentile of real visits. Between 200 and 500 ms needs improvement, and above 500 ms is poor. Google measures mobile and desktop separately, so check mobile first, where slower phones expose long tasks.

Why does PageSpeed Insights not show an INP value?

INP needs real interactions from Chrome users. If a page or origin has too little traffic, CrUX has no INP data. Lighthouse lab tests load the page without clicking, so they show Total Blocking Time instead. Use DevTools to measure INP yourself.

Does a caching plugin fix INP?

Page caching mainly improves server response time and LCP. INP depends on JavaScript running in the browser after the page loads. A cache plugin helps INP only through extra features such as delaying or deferring JavaScript, not through the cache itself.

Does delaying JavaScript always improve INP?

No. Delaying scripts frees the main thread during load, but the delayed scripts all run on the first interaction. If a menu or form script is delayed, that first tap can get slower. Delay tags and chat, and exclude interactive scripts.

How do I reduce INP on an Elementor site?

Keep Improved Asset Loading on, build with Flexbox containers instead of nested sections, remove unused addon packs and watch the DOM size. Then delay third-party tags. Element Caching helps server time, not INP, so do not rely on it for responsiveness.

What replaced First Input Delay?

Interaction to Next Paint replaced First Input Delay as a Core Web Vital on 12 March 2024. FID only measured the input delay of the first interaction. INP measures every click, tap and key press through the whole visit, including processing and painting time.

How long does it take for INP improvements to show in Search Console?

Field data in PageSpeed Insights and Search Console covers a rolling 28-day window. Improvements appear gradually as old visits drop out. After the numbers look good, use Validate fix in the Core Web Vitals report to start Google’s check.

Can a live chat widget hurt INP?

Yes. Chat widgets load sizeable third-party JavaScript and often run timers and listeners on the main thread. Load chat only on pages where someone answers it, or use a facade that loads the real widget when a visitor clicks the chat button.

Which INP fix should you do first?

  • Start with Step 3 if: DevTools shows chat, tag manager, ad or pixel scripts in the slow interaction. That is most content sites, and the fix takes an afternoon.
  • Start with Step 4 if: one plugin’s script shows up on pages that never use it, such as a form or slider on every post.
  • Start with Step 5 if: presentation delay is the largest phase and the page is built with a page builder.
  • Leave it alone if: field INP is good on mobile and desktop. Chasing a lab number past that point costs time and can break interactions.

Our pick for most StyleMyWP readers: trace one slow tap in DevTools, delay the third-party tags it reveals, unload one unused plugin script, and re-measure. That order starts with the cheapest fixes and leaves theme code for last.

Last updated November 2026.

Lokesh Kapoor
Lokesh Kapoor

Lokesh Kapoor is a web developer, blogger, and digital creator passionate about WordPress, SaaS, automation, and modern web technologies. He shares practical tutorials, honest insights, and useful resources to help creators, entrepreneurs, and website owners build faster, smarter, and more effective online experiences with confidence, clarity, and consistency.

Articles: 25

Leave a Reply

Your email address will not be published. Required fields are marked *