TL;DR, kort antwoord
8 min leestijdSession replay kost een pagina op drie plekken: het recorderscript dat bij de eerste laadbeurt wordt gedownload, de CPU op de main thread die DOM-mutaties omzet in events, en de uploadbandbreedte die die events verstuurt. De gepubliceerde benchmark van Sentry zette de replay-plugin op zo'n 36 KB gzipped en mat een stijging van de total blocking time van 2621,67 ms naar 3036,80 ms met replay aan, terwijl Largest Contentful Paint niet achteruit ging. De kosten vallen op de main thread, niet op het netwerk.
Vertraagt session replay de prestaties van je website?
Session replay kost een pagina op drie plekken, en daarom is het antwoord op "vertraagt session replay de prestaties van je website" ja: scriptbytes bij de eerste laadbeurt, CPU op de main thread om DOM-mutaties te serialiseren, en uploadbandbreedte tijdens het bezoek. Hoe groot elke kostenpost wordt, hangt af van de recorder, de grootte van de DOM van de pagina en de samplinginstellingen. Sentry publiceert een gedateerde benchmark met de methode erbij, en volgens die cijfers vallen de zichtbare kosten op de main thread, niet op het netwerk.
Wat zijn de drie kostenposten van het opnemen van een sessie?
Een recorder rekent één keer af bij het laden en daarna doorlopend voor de rest van het bezoek. De eenmalige kost is de bundle, die moet downloaden, parsen en uitvoeren voordat hij zijn eerste DOM-snapshot kan maken. De doorlopende kost verdeelt zich over CPU, die mutation records serialiseert naar JSON-events, en netwerk, dat die events in batches uploadt. Omdat session replay een bezoek opbouwt uit DOM-mutaties in plaats van videoframes, is de CPU-regel degene die meegroeit met je pagina.
| Kostenpost | Wanneer hij valt | Wat hem bepaalt | Wat jij in de hand hebt |
|---|---|---|---|
| Scriptbytes | Eerste laadbeurt, eenmalig | Gecomprimeerde grootte van de recorderbundle | Welke recorder, en of die async laadt |
| CPU op main thread | Eerste snapshot, daarna elke batch mutaties | Aantal DOM-nodes en mutatiesnelheid | Sampling, geblokkeerde subtrees, slimDOM |
| Uploadbandbreedte | Gedurende het hele bezoek | Aantal events na sampling en packing | Samplingintervallen, opnemen van mousemove |
Hoe groot is een session replay-script?
De recorderbundle is het enige deel waar een bezoeker voor betaalt voordat de pagina interactief wordt. Bundlephobia meet @rrweb/record 2.1.4, de opnamehelft van rrweb, op 23.262 bytes gzipped, en het volledige rrweb-pakket inclusief de player op 78.597 bytes gzipped. De documentatie van Sentry zelf zegt dat "as of version 7.78.0 the Session Replay plugin is an additional ~36KB gzipped" bovenop de error-SDK. Flowsery levert één script onder de 10 KB. Laad welke recorder je ook kiest asynchroon, zodat de bytes nooit vóór de eerste paint staan, en meet het verschil zelf in Lighthouse in plaats van een groottebadge te vertrouwen.
Hoeveel tijd op de main thread kost DOM-serialisatie?
De CPU-kosten concentreren zich in de eerste volledige snapshot en zakken daarna naar werk per batch voor de rest van de sessie. rrweb registreert een MutationObserver, en daarom staat in de gids dat rrweb "does not support IE11 and below because it uses the MutationObserver API"; die API geeft de recorder een batch records in de wachtrij in plaats van één keer per DOM-wijziging te vuren, dus serialisatie draait per batch en niet bij elke aanraking van een node. Voor de snapshot bestaan gepubliceerde cijfers: rrweb-issue #1337 mat de serialisatie van een volledige snapshot op gemiddeld 34,55 ms op een document met diep geneste divs, en 27,35 ms na het weghalen van herhaalde closest()-lookups.
Het artikel over long tasks op web.dev van Google definieert de drempel en de rekensom:
blocking time = task duration - 50 ms
Een snapshot van 34,55 ms draagt dus 0 ms blocking time bij, omdat "any task that takes longer than 50 milliseconds is a long task" en alles wat korter is niet meetelt. Snapshots op veel grotere DOM-bomen gaan wel over die grens, en de tracker van rrweb heeft de meldingen: issue #1547 zegt dat een interne check "lags by 1 to 3 seconds on pages with lots of nodes", en issue #1820 documenteert dat de main thread blokkeert als er een Zendesk-widget op de pagina staat. Er is geen openbare benchmark die het aantal DOM-nodes koppelt aan milliseconden serialisatie, dus beschouw elke claim van een leverancier over een vast CPU-cijfer per pagina als niet gemeten.
Recorders kunnen niet-urgent werk naar requestIdleCallback schuiven, maar de W3C-specificatie begrenst elke idle-deadline "to a maximum value of 50ms", zodat de browser ruimte houdt om binnen het venster van 100 ms te reageren dat als direct aanvoelt. MDN waarschuwt dat zonder een timeout-optie "it's possible multiple seconds will elapse before the callback is fired", dus idle-planning past bij compressie en upload, niet bij snapshots.

Hoeveel bandbreedte uploadt een session replay?
De benchmark van Sentry mat de netwerkupload voor zijn scenario: van 3,84 KB met alleen de error-SDK naar 272,51 KB met replay aan, terwijl de download gelijk bleef op 8,09 MB en 8,07 MB. Upload is de kost die zowel je server als de verbinding van je bezoeker draagt, en hij groeit lineair met het aantal opgenomen sessies:
monthly replay upload = uploaded bytes per session x sessions per month
Met de gemeten 272,51 KB per opgenomen scenario van Sentry en 50.000 sessies per maand is dat 13.625.500 KB, ofwel ongeveer 13 GB upload. Tekstzware apps met een DOM die langzaam verandert, komen daaronder uit en apps met veel canvas of animatie daarboven, en daarom bestaat het opslagrecept van rrweb.
Verandert session replay je Core Web Vitals?
In de gepubliceerde run van Sentry liet session replay Largest Contentful Paint en Cumulative Layout Shift ongemoeid en verschoof Total Blocking Time. De benchmark was "last updated on Sept 25, 2023" en draaide "on an Apple M1 MacBook Pro against a remote preview server and a remote API backend with 50 iterations".
| Mediaan | Geen SDK | Error-SDK | Error-SDK plus Replay |
|---|---|---|---|
| Largest Contentful Paint | 1599,19 ms | 1546,07 ms | 1529,11 ms |
| Cumulative Layout Shift | 0,40 | 0,40 | 0,40 |
| First Input Delay | 1,26 ms | 1,30 ms | 1,50 ms |
| Total Blocking Time | 2621,67 ms | 2663,35 ms | 3036,80 ms |
| Netwerkupload | 21 B | 3,84 KB | 272,51 KB |
Total Blocking Time steeg met 415,13 ms tussen de error-SDK en de build met replay, en Sentry merkt op dat een eenvoudigere testpagina "produced an increase of ~100 ms of total JS blocking time". De stabiliteit van de layout bewoog helemaal niet, wat klopt met hoe de metriek werkt: opnemen leest de DOM, en Cumulative Layout Shift scoort beweging daarin. Een M1-laptop is geen Android-telefoon uit het middensegment, en niemand heeft dezelfde benchmark op goedkope mobiele hardware gepubliceerd, dus meet Core Web Vitals uit je eigen velddata voordat je aanneemt dat de cijfers overdraagbaar zijn.
Hoe verlaag je de overhead van session replay zonder de replay te verliezen?
Sampling haalt de events weg die het meest kosten en het minst bewijzen. Het opslagrecept van rrweb raadt mousemove: false aan om muisbewegingen te laten vallen, scroll: 150 om hooguit één scroll-event per 150 ms uit te sturen, media: 800 voor media-interactie en input: 'last' om alleen de eindwaarde van een getypt veld op te nemen, met als argument dat sampling "can reduce the storage size by dropping some events". Naast sampling slaat blockClass hele subtrees over, omdat "an element with the class name .rr-block will not be recorded, instead it will replay as a placeholder", en slimDOMOptions haalt DOM-delen weg die geen waarde hebben voor de replay. Begin met mousemove en scroll op je zwaarste pagina en meet daarna opnieuw. Maskeren draait in dezelfde serialisatieronde, dus hoe je maskeren instelt verandert zowel de CPU-kosten als je privacyhouding.
Realtime dashboard
Doelen bijhouden
Tracking zonder cookies
Veelgestelde vragen
Blokkeert session replay de eerste render van een pagina?
Niet als de recorder asynchroon laadt, want een async script staat niet in het kritieke pad van de parser. Wat in de buurt van de eerste render kan vallen, is de eerste DOM-snapshot, die draait nadat de recorder start en meegroeit met het aantal nodes. In de benchmark van Sentry stond Largest Contentful Paint op 1529,11 ms met replay aan tegenover 1599,19 ms zonder SDK, dus de eerste paint was in die run niet het knelpunt.
Hoeveel voegt het recorderscript toe aan het paginagewicht?
Bundlephobia noemt @rrweb/record 2.1.4 op 23.262 bytes gzipped en de volledige rrweb-bundle op 78.597 bytes gzipped, en Sentry documenteert zijn Session Replay-plugin op ongeveer 36 KB gzipped bovenop de error-SDK. Het script van Flowsery is kleiner dan 10 KB. Controleer de gecomprimeerde overdrachtsgrootte in het netwerkpaneel van je browser, want ongecomprimeerde cijfers overdrijven wat een bezoeker downloadt.
Verhoogt session replay het dataverbruik van een bezoeker?
Ja, aan de uploadkant. Sentry mat 272,51 KB upload voor zijn benchmarkscenario met replay aan, tegenover 3,84 KB met alleen de error-SDK, terwijl het downloadvolume niet bewoog. Bezoekers op een mobiel abonnement met databundel betalen die upload, en dat is het sterkste argument om mousemove uit de stroom te samplen.

Waarom kost session replay op sommige pagina's meer CPU dan op andere?
Het serialisatiewerk hangt af van het aantal DOM-nodes en de mutatiesnelheid, niet van paginaweergaven. Een dashboard dat bij elke toetsaanslag een grote tabel opnieuw rendert, levert meer mutation records op dan een statisch artikel, en rrweb-issue #1547 meldt vertragingen van 1 tot 3 seconden "on pages with lots of nodes". Widgets van derden tellen ook mee, en dat is wat issue #1820 documenteert voor de Zendesk Web Widget.
Schaadt session replay je SEO-rankings?
Alleen via dezelfde weg als elk ander script: door je Core Web Vitals te verschuiven. De zoekdocumentatie van Google zegt dat de kernrankingsystemen een goede paginaervaring belonen, maar waarschuwt dat Core Web Vitals alleen geen rankings garanderen (Google Search Central). Omdat de meting van Sentry Total Blocking Time verschoof en Largest Contentful Paint en Cumulative Layout Shift gelijk liet, is de responsiviteit van de main thread de metriek om in de gaten te houden.
Hoe meet ik de overhead van session replay op mijn eigen site?
Laad je zwaarste pagina met de recorder uit, neem een prestatieprofiel op in Chrome DevTools, herhaal dat met de recorder aan en vergelijk scripttijd, aantal long tasks en overgedragen bytes. Draai elke configuratie een paar keer en vergelijk medianen, want losse runs variëren meer dan het effect dat je meet. Velddata van echte apparaten beslist wat een labprofiel alleen suggereert.
Bespaart het uitzetten van mousemove-tracking CPU-tijd of alleen bandbreedte?
Allebei. De kostentabel in dit artikel noemt sampling als knop voor zowel CPU op de main thread als uploadbandbreedte, want elk mousemove-event dat de recorder overslaat, is één mutation record minder om te serialiseren en één event minder om te versturen. Mousemove uitzetten met mousemove: false is dezelfde knop die het opslagrecept van rrweb als eerste aanraadt.
Wat telt als 'long task' die session replay moet vermijden?
Het artikel op web.dev van Google definieert een long task als alles wat langer dan 50 milliseconden op de main thread draait, met blocking time gelijk aan de taakduur min 50 ms. De benchmark van rrweb voor een volledige snapshot mat 34,55 ms op een document met geneste divs, wat onder die grens valt en nul blocking time bijdraagt. Snapshots op veel grotere DOM-bomen zijn degene die erover gaan, en dat is wat de eigen issuetracker van rrweb vastlegt in meldingen van vertraging van meerdere seconden.
Kan requestIdleCallback voorkomen dat session replay de main thread blokkeert?
Alleen voor werk dat kan wachten. Recorders kunnen compressie en upload naar requestIdleCallback schuiven, maar de W3C-specificatie begrenst elke idle-deadline op 50 ms, en MDN waarschuwt dat een callback zonder timeout-optie meerdere seconden kan blijven liggen voordat hij vuurt. Daardoor past idle-planning bij achtergrondwerk, niet bij de eerste DOM-snapshot die moet draaien zodra de recorder start.
Kost session replay meer op een trage CPU of op een trage netwerkverbinding?
In de gepubliceerde run van Sentry draagt de CPU het grootste deel van de kosten. De download bleef gelijk op 8,09 MB tegenover 8,07 MB met replay aan, terwijl Total Blocking Time steeg van 2621,67 ms naar 3036,80 ms, en de conclusie van dit artikel is dat de kosten op de main thread vallen, niet op het netwerk. De upload groeide wel van 3,84 KB naar 272,51 KB, dus een verbinding met databundel merkt het ook, alleen minder dan een trage CPU.
Was dit artikel nuttig?
Laat ons weten wat je ervan vindt!
Zie ons vaker in Google
Met één klik markeer je Flowsery als voorkeursbron, zodat onze artikelen hoger staan in je Topverhalen, AI-modus en AI-overzichten.
Voordat je gaat...
Flowsery
Analytics voor je website, met omzet voorop
Volg elke bezoeker, bron en conversie in realtime. Eenvoudig, krachtig en zonder cookies.
Realtime dashboard
Doelen bijhouden
Tracking zonder cookies
Gerelateerde begrippen


Wat rrweb vastlegt en hoe de privacyopties werken
Hoe rrweb een sessie vastlegt als DOM-snapshot plus mutaties, niet als video: de npm-pakketten, de MIT-licentie en privacyopties zoals maskAllInputs en blockClass.


Waar de standaardinstellingen voor PII-redactie in sessiereplay data blootleggen
De standaardinstellingen voor PII-redactie in sessiereplay lopen sterk uiteen: rrweb maskeert alleen wachtwoorden, Sentry alle tekst, Clarity cijfers en e-mails.


Hoe Cumulative Layout Shift echt wordt berekend
Elke Cumulative Layout Shift-score is impactfractie maal afstandsfractie, en Google rapporteert de grootste uitbarsting van verschuivingen, niet de som ervan.


Hoe Interaction to Next Paint je slechtste klik beoordeelt
Chrome beoordeelt Interaction to Next Paint op de slechtste interactie van een pagina en meet input delay, verwerking en presentatievertraging tot het volgende getekende frame.


Wat real user monitoring bewijst dat labtests niet kunnen
Real user monitoring is passief van opzet: het verzamelt prestatie- en foutdata uit bezoeken die echt plaatsvonden en rapporteert die op p75 in plaats van als gemiddelde.


Zo werkt session replay, en dit kan het niet zien
Een session replay bouwt een bezoek opnieuw op uit DOM-mutaties en invoer-events, niet uit video. Zie wat het vastlegt, wat maskering verbergt en hoe het verschilt van heatmaps.
Gerelateerde artikelen


Wat zeven leveranciers publiceren over de bewaartermijn van session replay-data
Bewaartermijnen van session replay-data vergeleken op basis van de docs van FullStory, Hotjar, Clarity, LogRocket, PostHog, Sentry en Datadog, plus wat de AVG vereist.


Waar de data vandaan komt bij session replay vs heatmaps
Session replay vs heatmaps: één bezoek tegenover veel, en hoe Hotjar, Datadog, PostHog, Clarity en FullStory heatmaps bouwen uit opnames, of los ervan.


Zo werkt een samplingpercentage voor session replay in Sentry, PostHog en andere tools
Een samplingpercentage voor session replay bepaalt welk deel van de bezoeken wordt opgenomen. Bekijk hoe Sentry, PostHog, LogRocket, Datadog en Clarity het documenteren.

