Interaction to Next Paint (INP): cos'è e come migliorarlo
Cosa misura l'INP, in cosa differisce dal FID e quale delle tre fasi correggere prima.
- Buono ≤ 200 ms
- Da migliorare ≤ 500 ms
- Scarso > 500 ms
Condividi
Cos'è l'Interaction to Next Paint (INP)?
L'Interaction to Next Paint (INP) è il Core Web Vital (CWV) per la reattività: il tempo che passa da un clic, un tap o la pressione di un tasto al frame successivo a schermo, misurato sull'interazione più lenta di una visita alla pagina. Un buon INP è di 200 millisecondi o meno al 75° percentile.
Un visitatore percepisce un cattivo INP come un pulsante che per un istante non fa nulla: tocca il menu, non cambia niente e tocca di nuovo. L'INP è uno dei tre Core Web Vitals, insieme a LCP e CLS, e Google li usa come segnale di ranking.
Nelle pagine in cui si clicca molto, l'INP ignora un valore anomalo ogni 50 interazioni. Una visita senza nemmeno un clic, un tap o la pressione di un tasto non ha alcun INP.
INP vs FID: cosa è cambiato a marzo 2024?
Il 12 marzo 2024 l'INP ha sostituito il First Input Delay (FID) come Core Web Vital. Il FID misurava solo l'attesa prima che il browser iniziasse a gestire la prima interazione di una visita. L'INP misura invece ogni interazione, dall'input al frame successivo a schermo.
L'INP calcola quindi anche il lavoro che il FID non vedeva: gli event handler eseguiti dopo l'attesa e le fasi di style, layout e paint prima che lo schermo cambi. Un clic il cui handler parte dopo 10 ms e poi gira per 300 ms superava il FID, ma fallisce con l'INP.
| First Input Delay (FID) | Interaction to Next Paint (INP) | |
|---|---|---|
| Interazioni | La prima | Ogni clic, tap e pressione di un tasto |
| Cosa viene misurato | Input delay | Input delay, processing duration e presentation delay |
| Buono | 100 ms o meno | 200 ms o meno |
| Valore per visita alla pagina | Il ritardo del primo input | L'interazione più lenta |
Quali interazioni misura l'INP?
L'INP misura clic, tap e pressione di tasti, tastiere su schermo incluse. Ogni tasto premuto mentre si scrive in un campo di un form è un'interazione a sé. Scroll, hover e zoom non contano come interazioni.
Il codice legato allo scroll può comunque rallentare un clic. Un clic su un link a un'ancora che avvia un'animazione di scroll in JavaScript è un'interazione, e il codice di scroll viene eseguito al suo interno. Un handler eseguito a ogni evento di scroll tiene occupato il main thread; quindi, un tap che arriva mentre il visitatore scorre la pagina deve attendere. In CSS, scroll-behavior: smooth garantisce lo scroll fluido senza alcuno script.
Le tre fasi di un'interazione INP (subpart)
Ogni interazione misurata dall'INP si compone di tre subpart consecutive: input delay, processing duration e presentation delay. L'INP di un'interazione è la loro somma, e la subpart più lunga è il punto da cui iniziare il fix. Chrome DevTools le mostra tutte e tre nell'insight di breakdown dell'INP di una traccia.

Un tap sul filtro "All" di una pagina di test strutturata come un portale di case vacanza, registrato nel pannello Performance: 369 dei 379 ms sono di processing duration, in gran parte layout che il click handler forza continuamente. Senza registrazione, lo stesso tap richiede 320 ms: la traccia stessa rallenta il tap.
- Input delay: l'input attende che il task già in esecuzione sul main thread sia terminato. Di solito si tratta di uno script in esecuzione durante il caricamento: un tag manager, un widget di chat o un framework ancora in fase di idratazione.
- Processing duration (detta anche processing time): vengono eseguiti gli event handler dell'interazione. Un handler è lento quando fa troppo lavoro contemporaneamente: ad esempio un tag di analytics che scatta al clic, oppure uno script che legge le dimensioni degli elementi dopo ogni modifica e forza continuamente il layout.
- Presentation delay: dopo gli handler, il browser ricalcola stili e layout, poi esegue il paint del frame successivo. Un DOM grande rende lenta questa fase, così come un re-render che modifica gran parte della pagina. Anche gli altri task eseguiti prima di quel frame vengono conteggiati qui.

Un tap mentre la pagina si stava ancora caricando, visto nel Core Web Vitals Visualizer. L'handler ha richiesto 0 ms; il frame successivo ha poi atteso 478 ms per il lavoro di caricamento della pagina, e qualsiasi attesa dopo l'handler conta come presentation delay.
Qual è un buon punteggio di INP?
Un buon INP è pari a 200 millisecondi o meno. Tra 200 e 500 millisecondi necessita di miglioramenti, e oltre 500 millisecondi è scarso. Google considera il 75° percentile (p75) dei caricamenti di pagina, separatamente per smartphone e desktop.

Al p75, tre caricamenti di pagina su quattro devono registrare un INP pari o inferiore a 200 ms, compresi quelli su smartphone lenti. Gli smartphone falliscono per primi: un processore più lento esegue lo stesso JavaScript più a lungo, quindi il main thread è occupato più spesso quando il visitatore fa tap.
Su CoreDash, l'INP su smartphone è risultato circa il doppio rispetto a quello su desktop. La tabella raggruppa i caricamenti di pagina di 149 progetti dall'11 ottobre al 7 novembre 2026:
| INP al p75 | Smartphone | Desktop |
|---|---|---|
| Tutte le interazioni | 170 ms | 89 ms |
| Durante il caricamento della pagina | 285 ms | 125 ms |
| Dopo il caricamento | 158 ms | 84 ms |
Negli stessi dati, la pressione dei tasti su desktop è risultata più lenta di clic e tap: 121 contro 85 ms.
Secondo lo State of Web Vitals, il 91,8% dei siti ha un buon INP su smartphone.
Come misurare l'Interaction to Next Paint (INP)
L'INP usato da Google proviene da visitatori reali su Chrome: il Chrome UX Report (CrUX), mostrato da PageSpeed Insights e Search Console. Uno strumento di real user monitoring (RUM) segnala quale clic è lento e su quale pagina, mentre Chrome DevTools ne mostra il motivo.
Search Console e PageSpeed Insights
Il report dei Core Web Vitals in Search Console raggruppa gli URL che non superano l'INP in base al problema riscontrato, indicando URL di esempio per ciascun gruppo. "INP issue: longer than 200ms (mobile)" indica che le visite da smartphone a quel gruppo di URL simili hanno un INP superiore a 200 ms al 75° percentile; "INP issue: longer than 500ms (mobile)" indica che supera i 500 ms. Il sito può sembrarti veloce anche quando il report segnala che non supera la soglia: molti visitatori usano smartphone più lenti del tuo e fanno tap mentre la pagina si sta ancora caricando. PageSpeed Insights mostra l'INP al p75 negli ultimi 28 giorni per un singolo URL, oppure per l'intero sito se quell'URL non ha visite sufficienti da Chrome. I fix si riflettono lentamente in entrambi: Search Console impiega fino a 28 giorni.

URL interessati al giorno per un problema di INP in Search Console.
Real user monitoring
CrUX fornisce un unico valore per URL o gruppo di URL. Uno script RUM sul sito misura invece ogni visita. In CoreDash guardo prima l'INP al p75 su mobile, suddiviso per elemento cliccato e per stato di caricamento.
Gli strumenti di RUM oggi misurano l'INP anche su Safari e Firefox. CrUX, e quindi Google, conteggia solo Chrome; per questo i numeri possono differire.
I tuoi clic in Chrome DevTools
Apri il pannello Performance in Chrome DevTools. Le metriche in tempo reale mostrano l'INP della sessione mentre clicchi, con un registro di ogni interazione e delle relative tre subpart. Imposta la CPU su 4x slowdown, in modo che il portatile si comporti più come uno smartphone, e prova a cliccare anche durante il caricamento della pagina. Per vedere cosa è stato eseguito, registra una traccia mentre clicchi: la traccia Interactions evidenzia l'interazione e la traccia Main mostra i task sottostanti. L'estensione Core Web Vitals Visualizer mostra lo stesso breakdown direttamente sulla pagina.
La libreria web-vitals registra in console ogni interazione che fa salire l'INP, con l'elemento e le relative subpart:
<script type="module">
import {onINP} from 'https://unpkg.com/web-vitals@6/dist/web-vitals.attribution.js?module';
onINP(console.log, {reportAllChanges: true});
</script> Lighthouse
Una normale analisi con Lighthouse non rileva l'INP: carica la pagina senza mai cliccare. Il valore di lab data più vicino è il Total Blocking Time (TBT), il tempo in cui il main thread è rimasto bloccato durante il caricamento. Di solito l'INP è molto più basso del TBT, ma migliorare il TBT aiuterà anche l'INP. Perché Lighthouse e i field data mostrano dati diversi: Lighthouse vs field data.
Come migliorare l'INP
Le interazioni più lente su smartphone determinano l'INP. Trovale nei field data (in Search Console o con un tool di RUM), osserva la subpart più lunga e riducila: meno JavaScript durante il caricamento per l'input delay, meno lavoro nell'event handler per la processing duration, meno elementi da renderizzare per il presentation delay. La guida passo passo all'INP accompagna dal report di Search Console fino alla riga di codice.
WordPress
Su un sito WordPress, inizia dagli script dei plugin caricati da ogni pagina: ciascuno di essi può far attendere un tap. Lo Script Manager di Perfmatters e Asset CleanUp permettono di disattivare gli script di un plugin nelle pagine che non li utilizzano, come il plugin di un form sulle pagine prodotto. Per ciò che risulta ancora lento dopo questo intervento, chiedi a uno sviluppatore una traccia: la registrazione del tap lento con CPU a 4x slowdown e il nome dello script eseguito al suo interno.
Le impostazioni di Delay JavaScript (Delay JavaScript execution in WP Rocket, Delay JavaScript in Perfmatters, Load JS Deferred impostato su Delayed in LiteSpeed Cache) trattengono gli script fino alla prima interazione per poi eseguirli tutti insieme. Questo fa guadagnare punti su Lighthouse, perché Lighthouse non tocca mai la pagina. Un visitatore reale tocca il menu e rimane ad attendere mentre il browser scarica ed esegue tutto; l'INP registrerà proprio il tap più lento della visita. Disattiva queste impostazioni se vuoi ottimizzare l'INP.
WP Core Web Vitals, il plugin di corewebvitals.io, applica il defer agli script nel loro ordine originale ed esegue analytics, pixel e widget di chat solo dopo il caricamento della pagina, senza attendere un tap.
Shopify
Ogni app Shopify appesantisce ogni clic: la installi per una singola funzionalità, ma il suo script viene caricato su pagine e clic che non c'entrano nulla con quella funzione. Nell'editor del tema, sotto App embed, disattiva le app una alla volta e misura di nuovo il tap lento dopo ciascuna. Gli app block inseriti in una sezione rimangono attivi anche disattivando l'embed dell'app: rimuovili all'interno di quella specifica sezione. Un'app rimossa può lasciare codice negli snippet del tema, quindi cerca il nome dell'app all'interno del tema.
Le impostazioni delle app modificano raramente ciò che viene eseguito durante un clic. È il codice del tema a deciderlo: cosa fa l'aggiunta al carrello, quando viene renderizzato il cart drawer, quali script delle app vengono caricati. Questo lavoro spetta a uno sviluppatore: l'handler dell'aggiunta al carrello deve aggiornare prima lo schermo e svolgere il resto solo dopo, mentre il cart drawer deve renderizzare soltanto ciò che è cambiato.
Input delay: meno JavaScript durante il caricamento
Un tap durante il caricamento deve attendere lo script in esecuzione in quel momento. Il pannello Coverage in DevTools mostra quale codice è stato eseguito fino a quel momento: uno script in gran parte inutilizzato dopo aver cliccato sulla pagina può essere rimosso, e gran parte di ciò che rimane può attendere il caricamento della pagina. Serve davvero un widget di chat durante i primi 500 ms di caricamento della pagina? Avvialo dopo l'evento load, quando il browser è inattivo (idle):
window.addEventListener('load', () => {
const whenIdle = window.requestIdleCallback || ((cb) => setTimeout(cb, 1));
whenIdle(() => {
const script = document.createElement('script');
script.src = '/js/chat-widget.js';
document.head.appendChild(script);
});
}); async e defer impediscono a uno script di bloccare il parser HTML, ma lo script viene comunque eseguito durante il caricamento, quindi aiutano più il LCP che l'INP. Altri modi per rimandare l'esecuzione di uno script sono spiegati in 16 metodi per rinviare o pianificare JavaScript.
Il browser attende un listener touchstart o wheel non passivo prima di scorrere la pagina. L'aggiunta di { passive: true } elimina quell'attesa, ma l'INP non misura lo scorrimento, quindi non ridurrà l'INP.
Spezza i long task (qualsiasi operazione superiore a 50 ms sul main thread), così il browser potrà gestire nel frattempo un tap in attesa. Rilascia il main thread (yield) dopo circa 50 ms di lavoro, a prescindere da quanto tempo richieda ogni singolo elemento:
function yieldToMain() {
if (globalThis.scheduler?.yield) {
return scheduler.yield();
}
return new Promise((resolve) => setTimeout(resolve, 0));
}
async function processItems(items) {
let lastYield = performance.now();
for (const item of items) {
processItem(item);
if (performance.now() - lastYield > 50) {
await yieldToMain();
lastYield = performance.now();
}
}
}
scheduler.yield() funziona su Chrome e Firefox; Safari riceve il fallback con setTimeout. Approfondisci in yield to the main thread.
Processing duration: aggiorna prima lo schermo
Un event handler veloce esegue prima ciò che il visitatore vede e rimanda tutto il resto a dopo il paint successivo. Un tag inserito nel click handler viene eseguito prima che lo schermo possa cambiare. Se viene spostato dopo l'aggiornamento, il visitatore vede prima il risultato e il tag viene eseguito comunque:
button.addEventListener('click', () => {
showConfirmation(); // what the visitor sees
requestAnimationFrame(() => {
setTimeout(() => {
// runs after the next frame is painted
dataLayer.push({ event: 'cta_click' });
}, 0);
});
});
Un requestIdleCallback() in questo punto si blocca su ogni iPhone: Safari non lo supporta, quindi l'handler genera un errore dopo l'esecuzione di showConfirmation(); il clic sembra funzionare, ma l'evento va perso. La versione per Tag Manager si trova in pianificare gli eventi del dataLayer; sul sito di un cliente, spostare dataLayer.push() a dopo il paint ha ridotto l'INP di 100 ms.
Per un form o un'aggiunta al carrello in attesa del server, mostra subito a schermo che il tap è stato recepito ("Aggiunta al carrello...") e lascia che la richiesta termini in seguito.
Il clic lento che riscontro più spesso riguarda i filtri di prodotto: l'handler aggiorna l'elenco, legge la nuova altezza, modifica un elemento in base a quell'altezza e legge di nuovo l'altezza. Ogni lettura dopo una modifica costringe il browser a ricalcolare il layout all'interno dell'handler. Su una pagina di test realizzata come un elenco di case vacanza in WordPress, un tap sul filtro "All" richiedeva 320 ms, di cui 298 ms impiegati per il layout forzato dallo script del tema. Facendo leggere allo script tutte le altezze all'inizio, o lasciando fare il lavoro al CSS, lo stesso tap ha richiesto 16 ms: un singolo frame. Entrambe le misurazioni sono state effettuate in Chrome a larghezza smartphone con CPU rallentata a 4x. In Forced reflow trovi il fix per temi, plugin, app e codice personalizzato.
Presentation delay: un DOM più piccolo, meno re-render
Un DOM troppo grande rallenta ogni frame successivo agli handler. Lighthouse lo segnala sotto "Optimize DOM size": come ridurre le dimensioni del DOM.
Nelle pagine lunghe, content-visibility: auto consente al browser di saltare il rendering delle sezioni esterne al viewport finché il visitatore non scorre in loro prossimità:
.product-reviews,
.site-footer {
content-visibility: auto;
contain-intrinsic-size: auto 600px;
}
Assegna a ciascuna di queste sezioni un valore di contain-intrinsic-size vicino alla sua altezza reale. Senza questo valore, una sezione saltata è alta zero pixel e la barra di scorrimento salta man mano che le sezioni vengono renderizzate.
Alcune single page application effettuano il re-render di troppo contenuto dopo ogni interazione: un clic modifica un solo contatore e mezza pagina viene renderizzata di nuovo. In React DevTools, "Highlight updates when components render" mostra quali componenti vengono renderizzati da un clic.
Debug dell'INP con la Long Animation Frames (LoAF) API
La Long Animation Frames (LoAF) API segnala ogni frame che ha richiesto più di 50 ms, indicando gli script eseguiti al suo interno: il file, la funzione e il tempo di esecuzione di ciascuno. In questo modo, un'interazione lenta nei field data viene associata al nome di uno script. LoAF funziona nei browser Chromium (Chrome 123 e successivi).
new PerformanceObserver((list) => {
for (const frame of list.getEntries()) {
if (frame.duration < 100) continue; // only the slowest frames
for (const script of frame.scripts) {
console.log(script.sourceURL, script.sourceFunctionName,
Math.round(script.duration) + ' ms');
}
}
}).observe({ type: 'long-animation-frame', buffered: true }); Uno strumento di RUM raccoglie queste voci da ogni visita. In CoreDash, apri INP, Breakdown e raggruppa per LOAF: ogni riga rappresenta uno script, con l'INP delle interazioni in cui è stato eseguito, suddiviso nelle tre subpart. Inizia dallo script con la barra più lunga su smartphone. La guida alla Long Animation Frames API spiega ogni campo di una entry.

CoreDash, raggruppato per LOAF (desktop): il verde indica l'input delay, il viola la processing duration e il blu il presentation delay.
Il tap lento dipende da uno script che non hai scritto tu, come un'app, un tag o un banner di consenso, e non sai quale eliminare? In una Core Web Vitals power hour analizziamo insieme i field data e la traccia di quel tap, e riceverai il fix per iscritto.

Ti serve un sito più veloce?
Sono Arjen e da 17 anni sistemo siti lenti. Se hai problemi che non riesci a risolvere da solo, mandami il tuo URL e ne parliamo.
Mandami il tuo URL
Perché il fix non funziona?
A volte la CDN serve ancora il vecchio HTML, oppure il fix è finito nel template desktop e il mobile ne usa un altro. Mandami il tuo URL e il problema, e ti rispondo con qualche orario. Prima analizzo i tuoi field data, poi dedichiamo un'ora al tuo sito, ed entro un giorno hai le mie note per iscritto. 350 € IVA esclusa.
Mandami il tuo URLNon hai uno sviluppatore per il fix? Faccio io il lavoro, su una copia del tuo sito.