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.
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 Delay | Interaction to Next Paint | |
|---|---|---|
| Interactions measured | First only | All of them |
| Part measured | Input delay only | Input to next frame |
| Good line | 100 ms | 200 ms |
| Core Web Vital | Until March 2024 | Since March 2024 |
INP Thresholds at a Glance
| Rating | INP at the 75th percentile |
|---|---|
| ✓ Good | ≤ 200 ms |
| ◐ Needs improvement | 200 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 counts | In 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.
| Phase | From | To | Usually long because |
|---|---|---|---|
| Input delay | Tap or click | Handler starts | Main thread busy |
| Processing duration | Handler starts | Handlers finish | Heavy event handlers |
| Presentation delay | Handlers finish | Next frame painted | Large 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
| Cause | Phase | Fix |
|---|---|---|
| Long tasks during load | Input delay | Split tasks, yield often |
| Third-party tags, chat widgets | Input delay | Load later or remove |
| Hydration of a large app | Input delay | Hydrate less, or later |
| Heavy event handler | Processing | Paint first, work after |
| Several handlers on one event | Processing | Merge or drop extras |
| Layout read after a write | Processing | Batch reads, then writes |
| Very large DOM | Presentation | Fewer nodes, content-visibility |
| Whole page re-renders | Presentation | Update only what changed |
| Unused or duplicated JavaScript | All three | Ship 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.
| Tool | Field | Lab | Says 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:
- HTML Is Over 2 MB or Core Web Vitals Miss the Good Range, which flags field INP over 200 ms
- Main-Thread Work Is Over 2 Seconds
- JavaScript Execution Time Is Over 1.3 Seconds
- One Third Party Runs 250 ms or More on the Main Thread
- Forced Reflow Is Over 30 ms
- Large DOM Causes Layout or Style Recalculation Over 40 ms
- JavaScript File Is Over the Lighthouse Line for Unused Code and Same JavaScript Module Is Shipped More Than Once
- Rage Clicks in Many Visitors' Sessions, with Microsoft Clarity connected
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
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.