Interaction to Next Paint (INP): wat het is en hoe je het verbetert

Wat INP meet, hoe het verschilt van FID en welke van de drie fasen je als eerste fixt.

  • Goed ≤ 200 ms
  • Verbetering nodig ≤ 500 ms
  • Slecht > 500 ms
Arjen Karel
Bijgewerkt · 12 min lezen
Delen

Wat is Interaction to Next Paint (INP)?

Interaction to Next Paint (INP) is de Core Web Vital (CWV) voor reactiesnelheid: de tijd vanaf een klik, tik of toetsaanslag tot het volgende frame op het scherm, gemeten bij de traagste interactie van een paginabezoek. Een goede INP is 200 milliseconden of minder op het 75e percentiel.

Een bezoeker merkt een slechte INP aan een knop die even niets doet: ze tikken op het menu, er verandert niets, dus tikken ze nog eens. INP is een van de drie Core Web Vitals, naast LCP en CLS, en Google gebruikt ze als rankingsignaal.

Op een pagina waar veel wordt geklikt, slaat INP per 50 interacties één uitschieter over. Een bezoek zonder ook maar één klik, tik of toetsaanslag heeft geen INP.

INP vs FID: wat veranderde er in maart 2024?

Op 12 maart 2024 verving INP First Input Delay (FID) als Core Web Vital. FID mat alleen de wachttijd voordat de browser begon met de afhandeling van de eerste interactie van een bezoek. INP meet elke interactie: vanaf de invoer tot het volgende frame op het scherm.

INP telt dus ook het werk mee dat FID nooit zag: de event handlers die na het wachten draaien, en de style, layout en paint voordat het scherm verandert. Een klik waarvan de handler na 10 ms start en daarna 300 ms draait, slaagde voor FID maar zakt voor INP.

First Input Delay (FID)Interaction to Next Paint (INP)
InteractiesDe eersteElke klik, tik en toetsaanslag
Wat wordt gemetenInput delayInput delay, processing duration en presentation delay
Goed100 ms of minder200 ms of minder
Waarde per paginabezoekDe vertraging van de eerste inputDe traagste interactie

Welke interacties meet INP?

INP meet klikken, tikken en toetsaanslagen, inclusief schermtoetsenborden. Elke toetsaanslag tijdens het typen in een formulierveld is een interactie op zich. Scrollen, hoveren en zoomen tellen niet mee als interactie.

Scrollcode kan een klik alsnog traag maken. Een klik op een ankerlink die een JavaScript-scrollanimatie start is een interactie, en de scrollcode draait daarbinnen. Een handler die op elk scroll-event draait houdt de main thread bezet. Komt er een tik binnen terwijl de bezoeker scrollt, dan moet die wachten. scroll-behavior: smooth in CSS regelt een smooth scroll zonder script.

De drie fasen van een INP-interactie (subparts)

Elke interactie die INP meet bestaat uit drie opeenvolgende subparts: input delay, processing duration en presentation delay. De INP van een interactie is de som van die drie, en bij het langste deel begint de fix. Chrome DevTools toont ze alle drie in het INP breakdown-inzicht van een trace.

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

Eén tik op het filter "All" van een testpagina gebouwd als overzicht van vakantiehuizen, opgenomen in het Performance-paneel: 369 van de 379 ms is processing duration, grotendeels layout die de click handler keer op keer afdwingt. Zonder opname duurt dezelfde tik 320 ms: de trace zelf vertraagt de tik.

  • Input delay: de input wacht tot de taak die al op de main thread draait klaar is. Meestal is die taak een script dat tijdens het laden draait: een tag manager, een chatwidget of een framework dat nog aan het hydraten is.
  • Processing duration (ook wel processing time genoemd): de event handlers voor de interactie draaien. Een handler is traag als die te veel tegelijk doet, bijvoorbeeld een analytics-tag die afgaat bij de klik, of een script dat na elke wijziging elementafmetingen uitleest en zo steeds opnieuw layout afdwingt.
  • Presentation delay: na de handlers berekent de browser styles en layout opnieuw, en paint daarna het volgende frame. Een grote DOM maakt dit traag, net als een re-render die het grootste deel van de pagina aanpast. Andere taken die vóór dat frame draaien, tellen hier ook mee.

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

Eén tik terwijl de pagina nog aan het laden was, in de Core Web Vitals Visualizer. De handler duurde 0 ms; het volgende frame wachtte daarna 478 ms op het laadwerk van de pagina, en wachten na de handler telt als presentation delay.

Wat is een goede INP-score?

Een goede INP is 200 milliseconden of minder. Tussen 200 en 500 milliseconden heeft verbetering nodig, en boven 500 milliseconden is slecht. Google neemt het 75e percentiel (p75) van paginaloads, apart voor telefoons en desktop.

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

Bij p75 moeten drie op de vier paginaloads een INP van 200 ms of minder hebben, inclusief die op trage telefoons. Telefoons zakken als eerste: een tragere processor doet langer over hetzelfde JavaScript, waardoor de main thread vaker bezet is op het moment dat de bezoeker tikt.

In CoreDash lag de INP op telefoons ongeveer twee keer zo hoog als op desktop. De tabel combineert de paginaloads van 149 projecten van 11 oktober tot 7 november 2026:

INP op p75TelefoonsDesktop
Alle interacties170 ms89 ms
Tijdens het laden van de pagina285 ms125 ms
Na het laden158 ms84 ms

In dezelfde data waren toetsaanslagen op desktop trager dan klikken en tikken: 121 tegenover 85 ms.

Volgens de State of Web Vitals heeft 91,8% van de sites een goede INP op telefoons.

Zo meet je Interaction to Next Paint (INP)

De INP die Google gebruikt is afkomstig van echte bezoekers in Chrome: het Chrome UX Report (CrUX), te zien in PageSpeed Insights en Search Console. Een tool voor real user monitoring (RUM) vertelt je welke klik op welke pagina traag is, en Chrome DevTools laat zien waarom.

Search Console en PageSpeed Insights

Het Core Web Vitals-rapport in Search Console groepeert URL's die zakken voor INP per probleem, met voorbeeld-URL's voor elke groep. "INP issue: longer than 200ms (mobile)" betekent dat bezoeken via telefoons aan die groep vergelijkbare URL's op het 75e percentiel een INP van boven de 200 ms hebben; "INP issue: longer than 500ms (mobile)" betekent boven de 500 ms. Je site kan voor jou snel aanvoelen terwijl het rapport zegt dat die zakt: veel van je bezoekers gebruiken een tragere telefoon dan jij, en ze tikken ook terwijl de pagina nog laadt. PageSpeed Insights toont de INP op p75 over de afgelopen 28 dagen voor één URL, of voor de hele site als die URL te weinig Chrome-bezoeken heeft. Een fix zie je in beide pas langzaam terug: Search Console heeft tot 28 dagen nodig.

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

Getroffen URL's per dag voor één INP-probleem in Search Console.

Real user monitoring

CrUX geeft één getal per URL of groep URL's. Een RUM-script op je eigen site meet elk bezoek. In CoreDash kijk ik eerst naar INP p75 op mobiel, uitgesplitst naar het aangeklikte element en de load state.

RUM-tools meten INP tegenwoordig ook in Safari en Firefox. CrUX, en daarmee Google, telt alleen Chrome mee. De cijfers kunnen dus verschillen.

Je eigen klikken in Chrome DevTools

Open het Performance-paneel in Chrome DevTools. De live metrics tonen tijdens het klikken de INP van je eigen sessie, inclusief een log van elke interactie en de drie subparts. Zet de CPU op 4x slowdown, zodat je laptop zich meer als een telefoon gedraagt, en klik ook terwijl de pagina nog laadt. Wil je zien wat er draaide, neem dan een trace op terwijl je klikt: de Interactions-track markeert de interactie en de Main-track toont de taken daaronder. De extensie Core Web Vitals Visualizer toont dezelfde breakdown op de pagina zelf.

De web-vitals-library logt elke interactie die de INP verhoogt naar de console, met het element en de subparts:

<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

Een normale Lighthouse-run heeft geen INP: die laadt de pagina en klikt nergens op. De labwaarde die het dichtst in de buurt komt is Total Blocking Time (TBT): de tijd dat de main thread tijdens het laden geblokkeerd was. INP is meestal een stuk lager dan TBT, maar verbeter je de TBT, dan verbetert de INP mee. Waarom Lighthouse en je field data verschillende cijfers tonen: Lighthouse vs field data.

Zo verbeter je INP

De traagste interacties op telefoons bepalen je INP. Zoek ze op in je field data (Search Console of een RUM-tool), bekijk hun langste subpart en pak die aan: minder JavaScript tijdens het laden voor input delay, minder werk in de event handler voor processing duration, minder renderen voor presentation delay. De stapsgewijze INP-handleiding leidt je van het Search Console-rapport naar de exacte regel code.

WordPress

Begin op een WordPress-site met de plugin-scripts die elke pagina laadt; elk script kan een tik namelijk laten wachten. De Script Manager van Perfmatters en Asset CleanUp zorgen dat plugin-scripts niet laden op pagina's die ze niet gebruiken, zoals een formulier-plugin op je productpagina's. Is het daarna nog steeds traag, vraag dan een developer om een trace: een opname van de trage tik met 4x vertraagde CPU, inclusief de naam van het script dat daarin draait.

De Delay JavaScript-instellingen (Delay JavaScript execution in WP Rocket, Delay JavaScript in Perfmatters, Load JS Deferred op Delayed in LiteSpeed Cache) houden scripts tegen tot de eerste interactie en draaien ze daarna allemaal tegelijk. Het levert een goede Lighthouse-score op, omdat Lighthouse de pagina nooit aanraakt. Een echte bezoeker tikt op het menu en moet wachten terwijl de browser alles downloadt en draait, en INP meet juist de traagste tik van het bezoek. Laat die instellingen uit staan voor INP.

WP Core Web Vitals, de plugin van corewebvitals.io, stelt de scripts uit in hun oorspronkelijke volgorde en draait analytics, pixels en chatwidgets pas nadat de pagina is geladen, zonder te wachten op een tik.

Shopify

Elke Shopify-app maakt elke klik iets trager: je installeert hem voor één feature, en het script laadt op pagina's en klikken die niets met die feature te maken hebben. Zet in de theme editor onder App embeds de apps één voor één uit en meet na elke app de trage tik opnieuw. App blocks die je in een sectie hebt geplaatst blijven actief als je de embed van de app uitzet: verwijder ze in die sectie. Een app die je hebt verwijderd kan code achterlaten in de snippets van het theme, dus zoek in het theme naar de naam ervan.

App-instellingen veranderen zelden wat er tijdens een klik draait. De theme-code bepaalt dat: wat add to cart doet, wanneer de cart drawer rendert en welke app-scripts laden. Dat deel is werk voor een developer: de add-to-cart-handler updatet eerst het scherm en doet de rest pas daarna, en de cart drawer rendert alleen wat er veranderd is.

Input delay: minder JavaScript tijdens het laden

Een tik tijdens het laden moet wachten op het script dat op dat moment draait. Het Coverage-paneel in DevTools toont welke code tot nu toe gedraaid heeft: een script dat na het doorklikken op de pagina nog steeds grotendeels ongebruikt is kan weg, en veel van wat overblijft kan wachten tot de pagina geladen is. Heb je die chatwidget echt nodig tijdens de eerste 500 ms van het laden? Start hem pas na het load-event, als de browser idle is:

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 en defer voorkomen dat een script de HTML-parser blokkeert, maar het script draait nog steeds tijdens het laden. Ze helpen daarom meer voor LCP dan voor INP. Andere manieren om een script later te draaien vind je in 16 methods to defer or schedule JavaScript.

Bij een touchstart- of wheel-listener die niet passief is, wacht de browser met scrollen tot die klaar is. Met { passive: true } neem je die wachttijd weg, maar INP meet scrollen niet; je INP wordt er dus niet lager van.

Hak je eigen long tasks op (alles boven de 50 ms op de main thread), zodat de browser tussendoor een wachtende tik kan afhandelen. Geef de main thread na ongeveer 50 ms werk terug (yield), ongeacht hoe lang één item duurt:

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() werkt in Chrome en Firefox; Safari krijgt de setTimeout-fallback. Meer hierover in yield to the main thread.

Processing duration: update het scherm eerst

Een snelle event handler doet eerst wat de bezoeker ziet en bewaart de rest voor na de volgende paint. Een tag in de click handler draait voordat het scherm kan veranderen. Zet je die achter de update, dan ziet de bezoeker eerst het resultaat en draait de tag alsnog:

button.addEventListener('click', () => {
  showConfirmation(); // wat de bezoeker ziet
  requestAnimationFrame(() => {
    setTimeout(() => {
      // draait na de paint van het volgende frame
      dataLayer.push({ event: 'cta_click' });
    }, 0);
  });
});

Een requestIdleCallback() op deze plek breekt op elke iPhone: Safari heeft dit niet, waardoor de handler een error gooit nadat showConfirmation() heeft gedraaid. De klik lijkt goed te gaan, terwijl het event verloren gaat. De Tag Manager-versie staat in scheduling dataLayer events; op de site van een klant scheelde het verplaatsen van dataLayer.push() naar na de paint 100 ms op de INP.

Wacht een formulier of een add to cart op de server, laat dan meteen op het scherm zien dat de tik gewerkt heeft ("Toevoegen aan winkelwagen...") en laat het request daarna afronden.

De trage klik die ik het vaakst zie is een productfilter: de handler updatet de lijst, leest de nieuwe hoogte uit, past op basis daarvan iets aan en leest de hoogte nogmaals uit. Elke leesactie na een wijziging dwingt de browser om binnen de handler opnieuw de layout te berekenen. Op een testpagina gebouwd als overzicht van vakantiehuizen in WordPress duurde een tik op het filter "All" 320 ms, waarvan 298 ms layout die het theme-script afdwong. Las het script eerst alle hoogtes uit, of deed CSS het werk van het script, dan duurde dezelfde tik 16 ms: één enkel frame. Beide zijn gemeten in Chrome op telefoonbreedte met een 4x vertraagde CPU. Forced reflow biedt de fix voor themes, plugins, apps en je eigen code.

Presentation delay: een kleinere DOM, minder re-renders

Een grote DOM maakt elk frame na de handlers trager. Lighthouse noemt dit onder "Optimize DOM size": zo maak je de DOM kleiner.

Op lange pagina's zorgt content-visibility: auto ervoor dat de browser het renderen van secties buiten de viewport overslaat totdat de bezoeker er dichtbij scrollt:

.product-reviews,
.site-footer {
  content-visibility: auto;
  contain-intrinsic-size: auto 600px;
}

Geef zo'n sectie altijd een contain-intrinsic-size die dicht bij de echte hoogte ligt. Zonder die waarde is een overgeslagen sectie nul pixels hoog, en verspringt de scrollbar zodra de secties renderen.

Sommige single page applications re-renderen veel te veel content na elke interactie: een klik past één teller aan en de halve pagina rendert opnieuw. In React DevTools laat "Highlight updates when components render" zien welke componenten renderen bij een klik.

INP debuggen met de Long Animation Frames (LoAF) API

De Long Animation Frames (LoAF) API rapporteert elk frame dat langer duurde dan 50 ms, inclusief de scripts die daarin draaiden: het bestand, de functie en hoe lang elk script duurde. Daarmee krijgt een trage interactie in je field data een scriptnaam. LoAF werkt in Chromium-browsers (Chrome 123 en hoger).

new PerformanceObserver((list) => {
  for (const frame of list.getEntries()) {
    if (frame.duration < 100) continue; // alleen de traagste 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 });

Een RUM-tool verzamelt deze entries van elk bezoek. Open in CoreDash INP, ga naar Breakdown en groepeer op LOAF: elke rij is een script, met de INP van de interacties waarin het draaide, uitgesplitst in de drie subparts. Begin met het script waarvan de balk het langst is op telefoons. De Long Animation Frames API-handleiding legt elk veld van een entry uit.

CoreDash INP subparts by LOAF: p75 INP per script, each split into input delay, processing and presentation.

CoreDash, gegroepeerd op LOAF (desktop): groen is input delay, paars processing duration, blauw presentation delay.

Zit de trage tik in een script dat je niet zelf hebt geschreven, zoals een app, een tag of een consent banner, en weet je niet welke je kunt schrappen? In een Core Web Vitals power hour lopen we samen door je field data en een trace van die tik, en krijg je de fix op schrift.

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

Een snellere site nodig?

Ik ben Arjen en ik maak al 17 jaar trage sites snel. Loop je tegen iets aan dat je zelf niet opgelost krijgt? Stuur me je URL, dan praten we even.

Stuur me je URL
Arjen Karel
Arjen Karel, Web performance consultant sinds 2009

Waarom werkt onze fix niet?

Soms serveert het CDN nog de oude HTML, of de fix zit in het desktop-template terwijl mobiel een ander template gebruikt. Stuur me je URL en het probleem, dan stuur ik je een paar momenten. Ik bekijk eerst je field data, daarna besteden we een uur aan je site, en binnen een dag heb je mijn notities op schrift. €350 excl. btw.

Stuur me je URL

Geen developer om de fix te bouwen? Ik doe het werk zelf, op een kopie van je site.

Arjen KarelINP nog steeds rood op mobiel?Stuur me je URL