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
Arjen Karel
Aggiornato il · 12 min di lettura
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)
InterazioniLa primaOgni clic, tap e pressione di un tasto
Cosa viene misuratoInput delayInput delay, processing duration e presentation delay
Buono100 ms o meno200 ms o meno
Valore per visita alla paginaIl ritardo del primo inputL'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.

Chrome DevTools Performance panel, one tap on a test page: INP 379 ms, INP breakdown with input delay 1 ms, processing duration 369 ms and presentation delay 9 ms

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.

Core Web Vitals Visualizer: INP 480 ms for a pointerdown while the page was loading, with the INP breakdown input delay 2 ms, processing time 0 ms and presentation delay 478 ms

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.

INP performance bar: GOOD ≤200 ms, NEEDS IMPROVEMENT 200 to 500 ms, POOR >500 ms

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 p75SmartphoneDesktop
Tutte le interazioni170 ms89 ms
Durante il caricamento della pagina285 ms125 ms
Dopo il caricamento158 ms84 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.

Google Search Console, Core Web Vitals report on mobile for acme-inp.com: INP issue: longer than 200ms (mobile), need improvement, 1,240 affected URLs, rising over three months

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 INP subparts by LOAF: p75 INP per script, each split into input delay, processing and presentation.

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.

About the author

Arjen Karel is a web performance consultant and the creator of CoreDash, a Real User Monitoring platform that tracks Core Web Vitals data across hundreds of sites. He also built the Core Web Vitals Visualizer Chrome extension. He has helped clients achieve passing Core Web Vitals scores on over 925,000 mobile URLs.

Arjen Karel

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
Arjen Karel
Arjen Karel, Consulente web performance dal 2009

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 URL

Non hai uno sviluppatore per il fix? Faccio io il lavoro, su una copia del tuo sito.

Arjen KarelINP ancora in rosso su mobile?Mandami il tuo URL