Part of the Core Web Vitals series. For the full picture, start with Core Web Vitals: what they are, how they affect SEO and how to improve them.
Interaction to Next Paint is the newest Core Web Vital and the hardest to test, because it depends on what real people do on the page. A page can load quickly and still feel broken: the menu doesn’t open for half a second, the “Add to cart” button seems dead, typing in a search box lags.
This guide explains what INP measures, how an interaction breaks down, and how to find and fix the causes.
What is Interaction to Next Paint?
INP measures how quickly a page visually responds to user input. web.dev defines it as a metric that “assesses a page’s overall responsiveness to user interactions by observing the latency of all click, tap, and keyboard interactions that occur throughout the lifespan of a user’s visit to a page” (INP).
What counts:
- Clicking with a mouse
- Tapping on a touchscreen
- Pressing a key on a keyboard
Scrolling, hovering and zooming don’t.
The reported value is essentially the slowest interaction in the visit. To avoid one random hiccup dominating on pages with lots of interactions, web.dev notes “we ignore one highest interaction for every 50 interactions.”
INP replaced First Input Delay as a Core Web Vital on March 12, 2024. FID only measured how long the first interaction waited to start; INP covers every interaction and the whole time until the screen updates.
What is a good INP?
| Rating | INP at the 75th percentile |
|---|---|
| Good | 200 ms or less |
| Needs improvement | Over 200 and up to 500 ms |
| Poor | Over 500 ms |
What happens during an interaction?
Every interaction has three phases, and each has different causes:
| Phase | What happens | Typical cause when it’s slow |
|---|---|---|
| Input delay | The browser waits before it can run your event handlers | Other long tasks on the main thread: script evaluation, timers, third-party code |
| Processing duration | Your event handlers run | Heavy work in click or input handlers; forced synchronous layout |
| Presentation delay | The browser renders the next frame | A large DOM, expensive style and layout work, rendering HTML with JavaScript |
How do you find slow interactions?
Start from field data. web.dev’s INP optimisation guide says “your journey in optimizing INP will start with field data”, ideally from a real-user monitoring (RUM) tool that also records which interaction was slow. Without RUM, PageSpeed Insights shows the Chrome UX Report’s INP for a URL or the whole site.
Then reproduce in the lab: open the page in Chrome DevTools, record a performance trace, and perform the interaction users perform. Long tasks around the interaction show which phase is slow. To attribute slow frames to specific scripts, see Long Animation Frames and INP.
Lighthouse can’t measure INP from a page load. Total Blocking Time (TBT), the time the main thread was blocked during load, is the lab proxy: a high TBT means long tasks that will also delay interactions.
Across a whole site
In Crawlens, Measure Core Web Vitals or Real-user data for all pages pulls CrUX data for your pages, and the audit flags Poor INP for real users (over 500 ms) and Core Web Vitals need improvement. Each tested URL’s Page speed tab adds the lab picture: TBT, the Lighthouse score and the biggest opportunities, such as unused JavaScript. Because INP needs enough real traffic, many URLs show the whole site’s value; the tab says when that’s the case.
How do you fix a slow INP?
Reduce input delay
- Break up long tasks. Script evaluation during load is a common source; web.dev notes that depending on a script’s size, it “can introduce long tasks on the main thread, which will delay the browser from responding to other user interactions.”
- Load less JavaScript up front. Defer non-critical scripts, remove unused code, split bundles by route.
- Audit third-party scripts. Tag managers, chat widgets, A/B testing and ad scripts often run long tasks at the worst moment.
Shorten processing duration
- Do less in event handlers. Update what the user needs to see first, then do the rest.
- Yield to the main thread. web.dev suggests breaking “up the work in event callbacks into separate tasks”, so the browser can paint between them.
- Avoid layout thrashing: reading layout values right after changing styles forces the browser into synchronous layout work.
Shorten presentation delay
- Keep the DOM small. “When DOMs get very large, rendering work tends to scale with increasing DOM size.”
- Be careful with client-side rendering of large chunks of HTML; the browser has to run the JavaScript, then parse and render the result before it can paint.
How do you confirm the fix?
Lab traces show the effect on the interaction you fixed straight away. Field INP updates as CrUX’s 28-day window rolls forward, and it reflects all interactions, so the number moves only when the common slow ones get faster. Measure again after a month and compare.
For how INP fits with the other two metrics, see the Core Web Vitals guide.
Checklist
- Field INP checked for mobile and desktop
- Slow interactions identified (RUM, or reproduced in DevTools)
- Long tasks during load broken up; unused JavaScript removed
- Third-party scripts deferred or removed where possible
- Event handlers do the visible update first and yield
- No layout thrashing in handlers
- DOM size kept under control
- Total Blocking Time watched as a lab proxy
- Field INP of 200 ms or less at the 75th percentile
Frequently asked questions
What is a good INP score?
200 milliseconds or less at the 75th percentile of page visits. Between 200 and 500 milliseconds needs improvement, and over 500 milliseconds is poor.
What is the difference between INP and FID?
First Input Delay measured only the input delay of a visit's first interaction. INP looks at the latency of all clicks, taps and key presses throughout the visit, including processing and the time to paint the next frame. INP replaced FID as a Core Web Vital on March 12, 2024.
Does scrolling count towards INP?
No. Only clicks, taps and keyboard interactions count. Scrolling, hovering and zooming are not included.
Can Lighthouse measure INP?
Not directly, because a standard Lighthouse run doesn't interact with the page. Total Blocking Time is the lab metric that correlates with INP, so use it as a proxy and rely on field data for the real value.
What is a long task?
A task that keeps the browser's main thread busy for more than 50 milliseconds. While it runs, the browser can't respond to input, which shows up as input delay in INP.