What Is Interaction to Next Paint?
Abbreviation: INPAlso known as: Interaction latency
Interaction to Next Paint (INP) is a Core Web Vitals metric that measures how quickly a page responds to user interactions like clicks, taps, and key presses.
Last reviewed: 6 August 2026 · Reviewed by iNet Ventures SEO Team
In plain English
INP measures the delay between a user doing something — like clicking a button or typing into a form — and the page showing a response. A low INP means the page feels snappy. A high INP means it feels stuck.
Technical definition
INP is a user-centric performance metric that observes all click, tap, and keyboard interactions throughout the lifetime of a page and reports the worst response latency, ignoring outliers. It replaced First Input Delay (FID) as a Core Web Vital in March 2024.
Quick example
A user clicks an "Add to basket" button. If the page takes 350 milliseconds to show any visual feedback, the INP for that interaction is poor. If it responds in 100 milliseconds, it is good.
Quick facts
| Meaning | The longest delay between a user interaction and the next visible response |
|---|---|
| Main category | Technical SEO |
| Used by | Developers, UX designers, performance engineers, and SEOs |
| Difficulty | Advanced |
| Importance | High |
| Common examples | Clicking buttons, opening menus, submitting forms, typing in search boxes |
| Still relevant? | Yes. INP is a Core Web Vitals metric and a confirmed Google page experience signal. |
Why Interaction to Next Paint matters
INP captures the moment a page feels interactive. A slow INP makes users think the page is broken or unresponsive.
It measures real interactivity
LCP measures loading. INP measures whether the page reacts once it has loaded.
It is a confirmed ranking signal
As a Core Web Vital, INP feeds into Google's page experience systems.
It affects conversions
Users abandon forms, carts, and checkout flows when clicks do nothing.
It is more comprehensive than FID
FID only measured the first input. INP measures the worst interaction on the page, making it a better quality signal.
How it works
INP tracks the time from interaction to the next visual update.
- 1
A user interacts
A click, tap, or key press triggers an event.
- 2
The main thread may be blocked
If the browser is busy running JavaScript, the event handler is delayed.
- 3
The handler runs
The registered JavaScript for the interaction is executed.
- 4
The next paint occurs
The browser renders the result of the interaction. INP measures the full time from input to that paint.
Types and variations
INP can be measured and affected by different interaction types.
Click INP
The response latency measured after a mouse or tap click.
Tap INP
The touch equivalent of a click on mobile devices.
Keyboard INP
The latency measured after a key press, such as typing in a search box.
Field INP
INP measured from real users in the Chrome User Experience Report.
Lab INP
INP measured in synthetic testing tools such as Lighthouse.
Real examples
What good and bad INP look like in real interfaces.
A lightweight checkout button
A user clicks "Pay now" and a spinner appears within 100 ms. The event handler is short and defers heavy work.
A search as you type with debounce
The input uses a debounced search that does not run on every keystroke. The page feels responsive and INP stays low.
A heavy analytics script on click
A tracking script processes a large payload synchronously on every button click. The visual response is delayed by 700 ms.
A form that blocks the main thread
A form validates and reformats data synchronously, freezing the page while the user types.
Best practices
A good INP is under 200 milliseconds. The main cause of poor INP is long tasks on the main thread.
What to do
- Break long JavaScript tasks into smaller chunks
- Defer non-critical scripts until after the page is interactive
- Use requestIdleCallback or scheduling for low-priority work
- Offload heavy computation to web workers where possible
- Optimise event handlers so they run quickly and return control
- Minimise third-party scripts that block the main thread
What to avoid
- Loading large JavaScript bundles on every page
- Running heavy analytics or tracking code during interaction
- Using long-running animations that block the main thread
- Letting input handlers perform synchronous work that stalls the page
- Testing only on fast desktop connections
Common mistakes
Assuming fast LCP means fast INP
A page can look loaded quickly and still respond slowly to clicks. INP measures a different part of the experience.
Measuring only the first interaction
INP looks at the worst interaction on the page, so a single smooth click does not guarantee a good score.
Ignoring field data
Real users on mid-range devices reveal INP issues that lab tests miss.
Why INP is the hardest Core Web Vital to fix
INP is the moment the page feels broken. A slow LCP is annoying, but a slow INP is personal. The user did something and the page ignored them. Fixing INP usually means understanding JavaScript scheduling, which can be more complex than compressing an image. But the reward is a page that feels genuinely fast to use.
- Users blame the page, not the script, for a slow response
- INP is affected by the whole JavaScript stack on the page
- Main thread congestion is the enemy of good INP
- Small, frequent interactions can cause more INP problems than one heavy load
- Good INP requires engineering and SEO to work together
How iNet Ventures approaches interaction to next paint
We diagnose INP by finding the worst interactions on the most important pages, then we remove the blockers.
Profile the worst interactions
We use Chrome DevTools and field data to identify which clicks, taps, or key presses are slowest.
Break up long JavaScript tasks
We split large scripts into smaller chunks so the browser can respond to input between them.
Defer non-essential work
We move analytics, tracking, and heavy calculations off the critical interaction path.
Re-test on real devices
We verify the fix with throttled mobile devices, where INP problems are most visible.
Continue learning
Frequently asked questions
What is a good INP score?
Google considers an INP under 200 milliseconds to be good, 200 to 500 milliseconds to need improvement, and over 500 milliseconds to be poor.
Did INP replace FID?
Yes. INP replaced First Input Delay as a Core Web Vital in March 2024 because it measures the whole page session, not just the first input.
How do I measure INP?
Use PageSpeed Insights, the Chrome User Experience Report, or Web Vitals libraries in the field. Lab tools are less reliable for INP than for LCP.
Definitions and guidance are reviewed against Google Search documentation, industry usage, and iNet Ventures editorial standards.
- Written by:
- iNet Ventures Editorial Team
- Reviewed by:
- iNet Ventures SEO Team
- Published:
- 6 August 2024
- Last reviewed:
- 6 August 2026
Spotted something out of date or incorrect? Tell us and we will review and correct it.
Need links that actually hold up?
White-label link building and digital PR, priced per placement. Every link comes with a live URL and the context behind it.