INP (Interaction to Next Paint): The 2026 Core Web Vital That’s Killing Your Rankings

You fixed your LCP. You compressed your images. You scored 90+ on PageSpeed. And your rankings still dropped.

The culprit is probably INP — Interaction to Next Paint. It became an official Google Core Web Vital in March 2024, and in 2026 it is quietly destroying rankings for thousands of WordPress sites that have never even heard of it.

This guide explains exactly what INP is, why it matters more than most developers realize, and how to fix it on WordPress — step by step.

Table of Contents

1. What Is INP?
2. INP vs FID: What Changed?
3. INP Score Thresholds
4. Why INP Is Killing Your Rankings in 2026
5. The Biggest WordPress INP Killers
6. How to Measure Your INP Score
7. How to Fix INP on WordPress (Step-by-Step)
8. FAQ

What Is INP (Interaction to Next Paint)?

INP measures how long it takes your page to visually respond after a user interacts with it — a click, a tap, a keypress. It captures every interaction during the entire page session, not just the first one.

In plain language: if a user clicks your menu button and it takes 600ms for anything to visually change, your INP is 600ms. Google sees that as a broken experience.

The metric captures three phases of an interaction:

• Input delay — time waiting for the main thread to become free
• Processing time — time for your event handlers to run
• Presentation delay — time for the browser to paint the new frame

Your site’s INP score is the worst interaction at the 98th percentile of all user sessions from Chrome’s real-user data (CrUX).

INP vs FID: What Changed?

Google replaced First Input Delay (FID) with INP in March 2024. FID only measured the delay on the very first interaction. INP measures every interaction across the full session.

Many sites that had “good” FID scores now fail INP because the deeper interactions (dropdown navigation, form inputs, filter clicks) were never measured before.

INP Score Thresholds (Google’s Official Benchmarks)

Your goal: INP under 200ms on mobile. Mobile is what Google primarily indexes and scores.

Why INP Is Killing Your Rankings in 2026

Core Web Vitals are a confirmed Google ranking signal. In 2026, with AI crawlers and Google’s Search Generative Experience prioritizing pages that load and respond fast, a poor INP score costs you in two ways:

1. Direct ranking penalty — Google demotes pages that fail Core Web Vitals when competing content is similar in quality
2. Indirect bounce rate damage — A 500ms+ INP feels “frozen” to users. They leave. Your engagement signals drop. Rankings follow.

Most WordPress site owners fixed LCP and CLS in 2024–2025 following the initial Core Web Vitals rollout. INP is the one that got skipped — and competitors who fix it first gain a real edge.

If you’ve already optimized your PageSpeed score, read our guide on WordPress Performance Optimization 2026 to see how INP fits into the full picture.

The Biggest WordPress INP Killers

These are the most common causes of poor INP on WordPress sites in 2026:

1. Heavy Page Builders (Elementor, Divi, WPBakery)

Page builders load massive JavaScript bundles that block the main thread. Every click triggers expensive DOM recalculations across hundreds of nested elements. Elementor alone can add 300–600ms to INP on complex pages.

2. Undeferred Third-Party Scripts

Live chat widgets (Intercom, Drift), Facebook Pixel, Google Tag Manager with multiple tags — these run on the main thread and directly compete with user interactions.

3. Auto-Playing Sliders and Carousels

Sliders run JavaScript loops in the background. When a user clicks something while a slider animation is mid-frame, the browser queues the click — adding hundreds of milliseconds of input delay.

4. Bloated WooCommerce Stores

WooCommerce product pages with AJAX cart updates, wishlist scripts, and product variation watchers are INP disasters. A user clicking “Add to Cart” can trigger 400ms+ of processing. See our WooCommerce Speed Optimization guide for the full fix.

5. Too Many Plugins with Frontend JavaScript

Every plugin that loads a .js file on the frontend adds to main thread congestion. 30+ active plugins is a common WordPress setup — and a common INP problem.

6. Inline Event Listeners on Large DOM Trees

Themes that attach click events to the entire document body or deeply nested elements cause the browser to bubble events through hundreds of nodes before responding.

How to Measure Your INP Score

Use these tools to find your current INP before you fix anything:

Tool 1: PageSpeed Insights (Field Data)

Go to pagespeed.web.dev and enter your URL. Scroll to “Core Web Vitals Assessment.” This shows your real-user INP from Chrome field data — the number Google actually uses for rankings.

Tool 2: Chrome DevTools — Performance Panel

Open DevTools → Performance tab → Record → click around your page → Stop. Look for Long Tasks (red bars over 50ms). These are your INP bottlenecks.

Tool 3: Web Vitals Chrome Extension

Install the Web Vitals extension. It shows live INP as you interact with any page — the fastest way to spot-check a specific interaction.

Tool 4: DebugBear (The LoAF API)

DebugBear uses the Long Animation Frames (LoAF) API — the 2026 gold standard for INP diagnosis. It tells you exactly which script caused the frame to run long.

How to Fix INP on WordPress (Step-by-Step)

Work through these fixes in order. Most sites resolve their INP issues by step 4.

Step 1: Defer All Non-Critical JavaScript

The fastest win. Add this to your functions.php or use a plugin like Flying Scripts:

// Defer all non-critical scripts
function rajan_defer_scripts( $tag, $handle, $src ) {
    $no_defer = array( 'jquery', 'jquery-core' );
    if ( in_array( $handle, $no_defer ) ) {
        return $tag;
    }
    return str_replace( ' src', ' defer src', $tag );
}
add_filter( 'script_loader_tag', 'rajan_defer_scripts', 10, 3 );

This removes scripts from the critical path so they stop blocking user interactions.

Step 2: Enable “Delay JavaScript” in Your Cache Plugin

If you use WP Rocket, LiteSpeed Cache, or NitroPack:

• WP Rocket: Settings → File Optimization → Delay JavaScript Execution → Enable
• LiteSpeed Cache: Page Optimization → JS Settings → Defer All JS → On
• NitroPack: Automatically handles this — verify in your INP report after enabling

Step 3: Remove or Lazy-Load Third-Party Scripts

Audit every third-party script loading on your pages:

// Load live chat only after user interaction
document.addEventListener('mousemove', loadChat, { once: true });
document.addEventListener('touchstart', loadChat, { once: true });

function loadChat() {
    // your chat widget init code here
}

This pattern — load on first interaction — keeps your main thread clean until the user actually needs those scripts.

Step 4: Break Up Long JavaScript Tasks

Any JavaScript task over 50ms blocks INP. Use scheduler.yield() to break long tasks into smaller chunks:

async function processItems(items) {
    for (const item of items) {
        processItem(item);
        // Yield to the browser after each item
        await scheduler.yield();
    }
}

For older browser support, use setTimeout(fn, 0) as a fallback.

Step 5: Reduce DOM Size

Google recommends under 1,400 DOM elements. Page builders frequently generate 3,000–5,000+ nodes. To check yours:

// Paste in browser console
document.querySelectorAll('*').length

If you’re over 1,400, consider switching to a lightweight theme like GeneratePress or Blocksy for new builds, or audit your page builder templates for unnecessary wrappers.

Step 6: Optimize WooCommerce Interactions

For WooCommerce stores, the Add to Cart and checkout interactions are the most INP-sensitive:

• Replace AJAX cart with a server-side redirect for simple products
• Remove variation swatcher plugins that watch every DOM change
• Disable WooCommerce’s cart fragments on pages without a cart widget

// Disable WooCommerce cart fragments (major INP fix for stores)
add_action( 'wp_enqueue_scripts', function() {
    if ( ! is_cart() && ! is_checkout() ) {
        wp_dequeue_script( 'wc-cart-fragments' );
    }
}, 11 );

Step 7: Audit and Reduce Active Plugins

Run the Query Monitor plugin to see every script loaded per page. Deactivate plugins that add JavaScript to the frontend but aren’t essential for that page type. Use Asset CleanUp to disable scripts per page/post type without deleting plugins.

For a full plugin-free approach to WordPress speed, see our WordPress 90+ PageSpeed Developer Guide.

INP Fix Priority Matrix

FAQ: INP and WordPress

Does INP directly affect Google rankings?

Yes. INP is part of the Core Web Vitals group, which is a confirmed Google page experience ranking signal. A “Poor” INP (500ms+) can suppress rankings when competing pages have similar content quality.

My PageSpeed score is 95 but INP is still “Needs Improvement” — why?

PageSpeed Insights lab score simulates a single page load with no interactions. INP is measured from real users interacting with your site in Chrome. The two metrics measure completely different things. See our WordPress Speed Optimization Checklist to align both.

What is a realistic INP target for WordPress?

Aim for under 200ms on desktop and under 300ms on mobile as a practical starting point. Sub-100ms is achievable on simple themes without page builders.

Does WP Rocket fix INP automatically?

WP Rocket’s “Delay JavaScript” feature helps significantly but does not fully solve INP on its own. It removes the most common input delay causes but cannot break up long tasks in your theme or third-party scripts.

How often does Google update my INP data?

Google uses a 28-day rolling window from Chrome User Experience Report (CrUX) data. Fixes you make today will take up to 28 days to fully reflect in PageSpeed Insights field data.

Final Checklist: Fix INP on WordPress in 2026

• Check current INP in PageSpeed Insights (Field Data section)
• Enable “Delay JavaScript” in your cache plugin
• Defer non-jQuery scripts via functions.php
• Lazy-load live chat and third-party widgets on first interaction
• Disable WooCommerce cart fragments on non-cart pages
• Check DOM element count — target under 1,400
• Audit plugins with Query Monitor and remove unused frontend scripts
• Recheck INP in 48–72 hours using Web Vitals Chrome extension
• Wait 28 days for Google field data to update

Wrapping Up

INP is the Core Web Vital most WordPress developers haven’t fixed yet — and that’s exactly why fixing it now gives you a competitive edge. LCP and CLS are well-covered ground. INP is not.

The good news: most WordPress INP problems come from deferred JavaScript and bloated third-party scripts. The low-effort fixes in steps 1–4 above resolve the majority of cases without touching your theme or redesigning anything.

If you want to go deeper on WordPress performance as a whole, read our WordPress Performance Optimization Deep Technical Guide — it covers INP alongside LCP, TTFB, and CLS in one complete developer playbook.

For a real-world example of what a full performance audit looks like in practice, see our case study: 8s to 2s load time with 40% more leads.

Have a specific INP issue on your WordPress site? lets contact us.