NeovaAdvanced SEO Platform

Interaction to Next Paint (INP): What It Measures and How to Fix It

Interaction to Next Paint measures how long a page takes to show a response after someone clicks, taps or types. A page can load in a second and still feel broken if a tap on Add to Cart does nothing for half a second. INP has been a Core Web Vital since March 2024, and the line Google draws is 200 milliseconds. Here is what it counts, why it gets slow and what fixes it.

Speed and Core Web Vitalsinteraction to next paintUpdated November 21, 2026By the Neova team

What Is Interaction to Next Paint?

Interaction to Next Paint (INP) observes the delay between a visitor's interaction and the next frame the browser paints, for every click, tap and key press during the whole visit. When the visitor leaves, the page's INP is usually its slowest interaction. On pages with many interactions, one outlier is ignored for every 50, so a single freak delay does not decide the score (web.dev).

INP replaced First Input Delay as a Core Web Vital on March 12, 2024. SEO ProCheck's complete guide to INP covers the history in more depth.

First Input DelayInteraction to Next Paint
Interactions measuredFirst onlyAll of them
Part measuredInput delay onlyInput to next frame
Good line100 ms200 ms
Core Web VitalUntil March 2024Since March 2024

INP Thresholds at a Glance

RatingINP at the 75th percentile
✓ Good≤ 200 ms
◐ Needs improvement200 to 500 ms
– Poor> 500 ms

As with the other Core Web Vitals, Google reads the 75th percentile of real visits over 28 days, for phones and desktops separately. Phones are where INP usually fails: the same JavaScript that runs in 50 ms on a laptop can take 200 ms or more on a mid-range Android phone.

What countsIn INP
Mouse click✓
Tap on a touch screen✓
Key press✓
Hover–
Scroll–
Pinch zoom–

The Three Phases of an Interaction

Every interaction splits into three parts. The INP article on web.dev names them; knowing which one is long tells you where to look.

PhaseFromToUsually long because
Input delayTap or clickHandler startsMain thread busy
Processing durationHandler startsHandlers finishHeavy event handlers
Presentation delayHandlers finishNext frame paintedLarge DOM, layout work

Input delay is often someone else's fault: a third-party script or a hydration task was running when the visitor tapped, so the handler had to wait. Processing duration is your own code. Presentation delay is the cost of drawing the result: style recalculation, layout and paint, which grow with the size of the DOM.

Common Causes of Slow INP and Their Fixes

CausePhaseFix
Long tasks during loadInput delaySplit tasks, yield often
Third-party tags, chat widgetsInput delayLoad later or remove
Hydration of a large appInput delayHydrate less, or later
Heavy event handlerProcessingPaint first, work after
Several handlers on one eventProcessingMerge or drop extras
Layout read after a writeProcessingBatch reads, then writes
Very large DOMPresentationFewer nodes, content-visibility
Whole page re-rendersPresentationUpdate only what changed
Unused or duplicated JavaScriptAll threeShip less code

The pattern behind most of these: the browser has one main thread, and while it runs your JavaScript it cannot respond to the visitor. Anything that keeps it busy for more than 50 ms at a time, a long task, is a risk to INP. SEO ProCheck has a case study on reducing Wikipedia's Total Blocking Time by 300 ms, the same kind of work.

Fixing Slow Interactions: Yield to the Main Thread

The most useful single change is to show the visitor something first and do the rest later. Update the button, open the menu or show a spinner, then hand the main thread back to the browser before the heavy work runs:

button.addEventListener('click', async () => {
  button.classList.add('is-loading');   // visible change first
  await yieldToMain();                   // let the browser paint
  updateCart();                          // the heavy work after
});

function yieldToMain() {
  if ('scheduler' in window && 'yield' in scheduler) return scheduler.yield();
  return new Promise(resolve => setTimeout(resolve, 0));
}

web.dev's guide to optimizing long tasks explains scheduler.yield() and the fallback. Other fixes that pay off on most sites:

  • Audit third parties. List every tag, what it does and who owns it. Remove the ones nobody can name.
  • Break up long loops that process lists, filters or analytics events, yielding between chunks.
  • Debounce input handlers on search boxes so each key press does not trigger a full re-render.
  • Keep the DOM small. Thousands of hidden menu items and off-screen product cards all slow down every layout.
  • Use CSS for animation instead of JavaScript that runs every frame.

How to Measure INP

INP needs real interactions, so it is a field metric. A lab test that only loads the page has nobody clicking. Lighthouse reports Total Blocking Time instead, which counts how long the main thread was blocked during load and is a useful stand-in for input delay.

ToolFieldLabSays which interaction
PageSpeed Insights✓TBT only–
Search Console Core Web Vitals report✓––
Chrome DevTools Performance panel–✓ as you click✓
web-vitals library✓–✓ with attribution
Chrome UX Report API✓––

To find the slow interaction, record a trace in DevTools with CPU throttling at 4x, then click the menu, the filters and the add to cart button the way a visitor would. The interactions track marks the slow ones. The web-vitals library with attribution can send the same detail from real visitors to your analytics. SEO ProCheck's INP too high diagnosis page lists more ways to narrow it down. For a whole site at once, see the bulk page speed test guide.

Find INP Problems With Neova

Neova reads field INP from the Chrome UX Report with your free API key: the 75th percentile of real Chrome users on phones, per page group, with a 40-week trend and an alert when the grade changes. With Lighthouse on in New Crawl, lab checks run on one HTML page per page group and flag the main-thread work behind slow interactions:

Rage clicks are not INP, but a page where 3% or more of sessions have them is often a page where something did not respond in time. Every check runs on every plan, Free included, on . The Core Web Vitals checker guide covers the other two metrics. See Features or download Neova.

Questions

What is a good interaction to next paint?

200 milliseconds or less at the 75th percentile of real visits. Between 200 and 500 ms needs improvement, and over 500 ms is poor.

What replaced First Input Delay?

Interaction to Next Paint replaced First Input Delay as a Core Web Vital on March 12, 2024. FID measured only the wait before the first interaction was handled; INP measures every interaction until the next frame is painted.

Can Lighthouse measure INP?

Not during a page load test, because nobody interacts. Lighthouse reports Total Blocking Time instead. Its timespan mode and the DevTools Performance panel can measure interactions you perform yourself.

Why is INP worse on phones?

Phones have slower processors, so the same JavaScript takes longer to run and the main thread stays busy longer. Test with CPU throttling and read the phone field data first.

Does scrolling count toward INP?

No. Only clicks, taps and key presses count. Hover, scroll and zoom are not interactions for INP.

Take this with you

The assistant links open with a question about this page already written.

Crawl your site with NeovaThe Free plan runs every check on Mac, Windows and Linux. No credit card required.

Keep Reading