TL;DR, kort antwoord
8 min leestijdHet verschil tussen sendBeacon en fetch keepalive zit in controle, niet in aflevering. navigator.sendBeacon() zet een POST in de wachtrij die de pagina overleeft en geeft alleen true of false terug, met een Content-Type die de browser afleidt uit het type body dat je meegeeft. fetch() met keepalive op true voegt eigen headers, andere methoden en de response toe, en beide putten uit hetzelfde budget van 64 kibibytes onderweg dat in de WHATWG Fetch-standaard is vastgelegd.
Wat is het verschil tussen sendBeacon en fetch keepalive?
Het praktische verschil tussen sendBeacon en fetch keepalive is controle: navigator.sendBeacon() zet een POST in de wachtrij die de pagina overleeft, maar geeft niets terug behalve true of false, terwijl je met fetch() en keepalive: true de methode kiest, eigen headers instelt en de serverresponse leest. De W3C Beacon-specificatie is expliciet: "The sendBeacon() method does not provide ability to customize the request method, provide custom request headers, or change other processing properties of the request and response. Applications that require non-default settings for such requests should use the [FETCH] API with keepalive set to true." Onder de motorkap draaien beide op dezelfde fetch-machinerie, dus voor beide geldt één groottelimiet.
Hoeveel data kunnen sendBeacon en fetch keepalive versturen?
Een keepalive-verzoek draagt een body van maximaal 64 kibibytes, oftewel 65.536 bytes. De WHATWG Fetch-standaard dwingt die limiet af in HTTP-network-or-cache fetch, voordat het verzoek het netwerk bereikt:
If contentLength is non-null and httpRequest's keepalive is true, then:
- Let inflightKeepaliveBytes be 0.
- Let group be httpRequest's client's fetch group.
- Let inflightRecords be the set of fetch records in group whose request's keepalive is true and done flag is unset.
- For each fetchRecord of inflightRecords:
- Let inflightRequest be fetchRecord's request.
- Increment inflightKeepaliveBytes by inflightRequest's body's length.
- If the sum of contentLength and inflightKeepaliveBytes is greater than 64 kibibytes, then return a network error.
De toelichting in de spec verklaart het getal: "The above limit ensures that requests that are allowed to outlive the environment settings object and contain a body, have a bounded size and are not allowed to stay alive indefinitely." Meet de geserialiseerde payload in bytes, niet in tekens, voordat je erop vertrouwt dat hij past.
Wordt de limiet van 64 KiB gedeeld door keepalive-verzoeken die onderweg zijn?
De limiet wordt gedeeld, hij geldt niet per aanroep. Stap 5 hierboven telt contentLength op bij inflightKeepaliveBytes, de totale bodylengte van elk onvoltooid keepalive-verzoek in de fetch group. De Beacon-specificatie zegt hetzelfde van haar kant: "Requests initiated via the Beacon API automatically set the keepalive flag, and developers can similarly set the same flag manually when using the Fetch API. All requests with this flag set share the same in-flight quota restrictions that is enforced within the Fetch API." Een aanroep van sendBeacon() en een aanroep van fetch(..., { keepalive: true }) concurreren om één budget.
De ruimte die er voor je volgende aanroep overblijft is:
remaining bytes = 65536 - (sum of body lengths of unfinished keepalive requests)
Stel dat een foutrapport van 12.288 bytes en een batch klikken van 8.192 bytes allebei onderweg zijn. De ruimte is dan 65.536 min 20.480, oftewel 45.056 bytes. Een sessiesamenvatting van 50.000 bytes duwt de som naar 70.480, dus fetch() geeft een netwerkfout en sendBeacon() geeft false. Bundel elke payload voor eventtracking in één flush en die rekensom bijt niet meer.
Welk Content-Type stelt sendBeacon in per type body?
Met sendBeacon kun je Content-Type nooit zelf instellen: de browser leidt het af uit het type body dat je meegeeft, en die waarde bepaalt of het verzoek in de modus no-cors blijft of een CORS-preflight veroorzaakt. Het verwerkingsmodel van de Beacon-specificatie beschrijft die vertakking:
If contentType is not null:
- Set corsMode to "cors".
- If contentType value is a CORS-safelisted request-header value for the
Content-Typeheader, set corsMode to "no-cors".- Append a
Content-Typeheader with value contentType to headerList.
De Fetch-standaard definieert de safelisttest voor die header: "If mimeType's essence is not application/x-www-form-urlencoded, multipart/form-data, or text/plain, then return false." Fetch legt ook vast welk Content-Type elk type body oplevert:
| Body die je aan sendBeacon meegeeft | Content-Type dat de browser instelt | Op de CORS-safelist | Gevolg bij cross-origin |
|---|---|---|---|
| ArrayBuffer, TypedArray, DataView | geen | geen header verstuurd | no-cors, geen preflight |
| String | text/plain;charset=UTF-8 | Ja | no-cors, geen preflight |
| URLSearchParams | application/x-www-form-urlencoded;charset=UTF-8 | Ja | no-cors, geen preflight |
| FormData | multipart/form-data; boundary=... | Ja | no-cors, geen preflight |
Blob met type application/json | application/json | Nee | CORS-modus, preflight vereist |
De Beacon-specificatie noemt het gevolg: "If the request does not contain a payload, or the request Content-Type is a CORS-safelisted request-header, then the request mode is no-cors." Anders, in de woorden van de spec, "a CORS preflight is made and the server needs to first allow such requests by returning the appropriate set of CORS headers: Access-Control-Allow-Credentials, Access-Control-Allow-Origin, Access-Control-Allow-Headers." Een preflight verdubbelt het aantal round trips op een pagina die al aan het afsluiten is, dus stuur JSON als gewone string en parse het op de server.
![]()
Waarom moet een beacon afgaan bij pagehide in plaats van unload?
Laat de beacon eerst afgaan bij visibilitychange en daarna bij pagehide, en blijf van unload af, want unload breekt de back/forward cache. De MDN-pagina over sendBeacon zegt het zonder omwegen: "the unload event is incompatible with the back/forward cache (bfcache) implemented in modern browsers. Some browsers, such as Firefox, handle this incompatibility by excluding pages from the bfcache if they contain unload handlers, thus hurting performance." MDN raadt pagehide aan als terugvaloptie voor browsers zonder visibilitychange: "Like beforeunload and unload, this event is not reliably fired, especially on mobile. However, it is compatible with the bfcache."
De Beacon-specificatie voegt de reden voor mobiel toe: "Developers should avoid relying on unload event because it will not fire whenever a page is in a background state (i.e. visibilityState equal to hidden) and the process is terminated by the mobile OS." De volledige afweging tussen de exit-events staat in beforeunload tegenover pagehide.
Realtime dashboard
Doelen bijhouden
Tracking zonder cookies
Hoe schrijf je een sendBeacon-aanroep die unload overleeft?
Geef een gewone string mee, controleer de boolean die terugkomt en leeg de buffer pas als de browser de wachtrij accepteert:
const endpoint = 'https://collect.example.com/session';
const buffer = { sessionId: crypto.randomUUID(), events: [] };
function flush() {
if (buffer.events.length === 0) return;
const body = JSON.stringify(buffer);
if (navigator.sendBeacon(endpoint, body)) {
buffer.events.length = 0;
}
}
document.addEventListener('visibilitychange', () => {
if (document.visibilityState === 'hidden') flush();
});
window.addEventListener('pagehide', flush);De string als body levert text/plain;charset=UTF-8 op, dat op de safelist staat, dus de cross-origin POST slaat de preflight over. Komt er false terug, dan ging de payload plus alles wat onderweg was over de 65.536 bytes, en blijft de buffer bewaard voor de volgende poging.
Hoe schrijf je dezelfde aanroep met fetch keepalive?
Zet keepalive: true, voeg de headers toe die sendBeacon niet meeneemt en accepteer dat de promise alleen resolvet als de pagina lang genoeg blijft bestaan om het te zien:
window.addEventListener('pagehide', () => {
fetch('https://collect.example.com/session', {
method: 'POST',
keepalive: true,
headers: {
'Content-Type': 'application/json',
'X-Api-Key': apiKey,
},
body: JSON.stringify(buffer),
}).catch(() => {});
});Zowel Content-Type: application/json als de eigen header X-Api-Key vallen buiten de CORS-safelist, dus een cross-origin aanroep veroorzaakt hier een OPTIONS-preflight en vereist Access-Control-Allow-Headers op de server. Eén beperking geldt alleen voor keepalive: het algoritme extract-a-body van de Fetch-standaard gooit een TypeError voor een body van het type ReadableStream als de vlag aanstaat, dus streamen bij het afsluiten is geen optie. Dat moment van afsluiten is precies waarom een licht script zijn waarde bewijst, en waarom de prestatie-impact van session replay zich bij de flush laat zien en niet bij het opnemen.
Welke moet je gebruiken?
Gebruik sendBeacon voor analytics die je verstuurt en vergeet, en fetch keepalive zodra een header, een methode of de response ertoe doet.
| Vereiste | sendBeacon | fetch keepalive |
|---|---|---|
| HTTP-methode | Alleen POST | Elke methode |
| Eigen request-headers | Niet ondersteund | Ondersteund |
| Controle over Content-Type | Afgeleid van het type body | Door jou ingesteld |
| Serverresponse | Niet beschikbaar | Leesbaar via de promise |
| Grootte van de body | Deelt het budget van 64 KiB | Deelt hetzelfde budget |
| Beschikbaar in service workers | Nee | Ja |
Boven de 64 kibibytes werkt geen van beide: neem een steekproef van de payload, splits hem op of verplaats de aggregatie naar de server, een keuze die wordt besproken in client-side tegenover server-side analytics.
![]()
Veelgestelde vragen
Betekent true als returnwaarde van sendBeacon dat de server de data ontving?
Nee. De Beacon-specificatie zegt dat true "implies the browser has queued the data for transfer" en dat "since the actual data transfer happens asynchronously, this method does not provide any information whether the data transfer has succeeded or not." Het enige andere signaal is false, en dat betekent dat de wachtrij de payload weigerde.
Kan ik een Authorization-header instellen op sendBeacon?
Nee. De Beacon-specificatie stelt dat sendBeacon "does not provide ability to customize the request method, provide custom request headers, or change other processing properties of the request and response." Verplaats de credential naar het URL-pad, een cookie of de body, of stap over op fetch() met keepalive: true.
Waarom veroorzaakt mijn sendBeacon-Blob een CORS-preflight?
Omdat het type van de Blob het Content-Type van het verzoek wordt, en application/json staat niet op de CORS-safelist. De Fetch-standaard beperkt die safelist tot application/x-www-form-urlencoded, multipart/form-data en text/plain, dus al het andere dwingt een OPTIONS-preflight af. Stuur de JSON als string en het verzoek blijft in no-cors.
Geldt de limiet van 64 KiB per verzoek of per pagina?
Per fetch group, over alle onvoltooide keepalive-verzoeken daarin. De Fetch-standaard telt de contentLength van de nieuwe body op bij inflightKeepaliveBytes en geeft boven de 64 kibibytes een netwerkfout, dus een grote beacon die nog onderweg is verkleint de ruimte voor de volgende.
Werkt fetch keepalive in een service worker?
Ja. MDN noemt beschikbaarheid in service workers als voordeel van fetch() met keepalive ten opzichte van sendBeacon(), naast andere methoden dan POST, eigen request-eigenschappen en toegang tot de response.
Wat gebeurt er met een keepalive-verzoek als de gebruiker het tabblad meteen sluit?
De browser houdt het verzoek in leven na het document dat het startte, en dat is precies het doel van de vlag. De Fetch-standaard beschrijft keepalive als iets dat "the request to outlive the environment settings object" toestaat, en de limiet bestaat zodat die overlevende verzoeken "have a bounded size and are not allowed to stay alive indefinitely." Wat je kwijtraakt is de response: de promise heeft geen levende pagina meer om in te resolven.
Kan sendBeacon andere methoden dan POST gebruiken?
sendBeacon verstuurt alleen POST, zoals de vergelijkingstabel laat zien. fetch met keepalive accepteert elke methode, dus stap over op fetch als het endpoint PUT, PATCH of GET verwacht.
Waarom faalt een streaming body met fetch keepalive?
Het algoritme extract-a-body van de Fetch-standaard gooit een TypeError voor een body van het type ReadableStream zodra keepalive aanstaat, dus een stream kan de pagina bij het afsluiten niet verlaten. Serialiseer de payload met JSON.stringify of geef een string als body mee.
Realtime dashboard
Doelen bijhouden
Tracking zonder cookies
Moet ik naar pagehide en visibilitychange samen luisteren, of er een kiezen?
Laat eerst visibilitychange afgaan, omdat dat een tabblad vangt dat naar de achtergrond gaat voordat de pagina echt sluit, en voeg pagehide toe als terugvaloptie voor browsers waar visibilitychange niet betrouwbaar afgaat. De flushfunctie in het voorbeeld van dit artikel koppelt beide listeners en laat de eerste die afgaat de beacon versturen.
Wat moet ik doen als mijn payload boven de 64 KiB uitkomt?
Noch sendBeacon noch fetch keepalive kan een body van meer dan 65.536 bytes dragen; het verzoek geeft een netwerkfout of false zodra het gedeelde budget is overschreden. Neem een steekproef van de payload, verdeel hem over meerdere flushes of verplaats de aggregatie naar de server.
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


Waarom beforeunload vs. pagehide bepaalt of je analytics overleven
Een vergelijking van beforeunload vs. pagehide laat zien waarom mobiel beforeunload overslaat, de back-forward cache blokkeert, en waarom pagehide met sendBeacon data betrouwbaar verstuurt.


Wat de bfcache doet met terugnavigaties en je aantal paginaweergaven
De bfcache, of back/forward cache, herstelt een pagina uit het geheugen bij klikken op terug en vooruit. Welke pagina's in aanmerking komen, en waarom analytics ze mist of dubbel telt.


Waarom CNAME-cloaking trackers niet meer verbergt voor Safari of Brave
Trackers gebruikten CNAME-cloaking om zich als je subdomein voor te doen. Zie hoe de DNS-truc werkt, waarom Safari de cookies op 7 dagen begrenst en hoe Brave en uBlock de cloaking ontmaskeren.


Hoe cookie syncing advertentie-ID's over websites heen koppelt
Adtechbedrijven gebruiken cookie syncing om gebruikers-ID's uit te wisselen via redirects en pixels. Zie wat Safari, Firefox en Chrome ertegen doen en waarom analytics het overslaat.


Zo bouw je berekende statistieken in GA4 binnen een quotum van vijf plekken
Google beperkt berekende statistieken in GA4 tot 5 per standaardproperty. Leer de formulesyntaxis, de eenheden, waar ze verschijnen en wat een formule niet mag gebruiken.


Contentgroepering in GA4 instellen met één parameter
Stel contentgroepering in GA4 in met de parameter content_group in gtag of Tag Manager, lees de dimensie Content group en houd (not set)-rijen eruit.
Gerelateerde artikelen


Annotaties toevoegen in GA4 en een wijzigingslog bijhouden
In GA4 zetten Google Analytics-annotaties een gedateerde notitie op lijngrafieken. Wie ze kan toevoegen, de limieten van 60 en 150 tekens, het maximum van 1.000 en gebruik als wijzigingslog.


Zo werkt een opt-out voor Google Analytics, en wat elke methode blokkeert
Een opt-out voor Google Analytics kan een browserextensie zijn, een ga-disable-vlag op window of geweigerde toestemming. Wat elke methode blokkeert, wie er de baas over is en waar ze ophoudt.


Zo serveert Google tag gateway je Google-tag vanaf je eigen domein
Met Google tag gateway laadt de Google-tag vanaf je eigen domein en lopen hits via je CDN. Wat het verandert aan de nauwkeurigheid van data, en hoe je het instelt.