Woordenlijst

Waarom sendBeacon of fetch keepalive een beslissing van 64 KiB is

Taras Shynkarenko
Taras Shynkarenko
•Bijgewerkt: •8 min leestijd
Waarom sendBeacon of fetch keepalive een beslissing van 64 KiB isWaarom sendBeacon of fetch keepalive een beslissing van 64 KiB is

TL;DR, kort antwoord

8 min leestijd

Het 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:

  1. Let inflightKeepaliveBytes be 0.
  2. Let group be httpRequest's client's fetch group.
  3. Let inflightRecords be the set of fetch records in group whose request's keepalive is true and done flag is unset.
  4. For each fetchRecord of inflightRecords:
    1. Let inflightRequest be fetchRecord's request.
    2. Increment inflightKeepaliveBytes by inflightRequest's body's length.
  5. 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.

Waar het budget van 64 KiB naartoe gaat
Foutrapport12.288 bytes
Batch klikken8.192 bytes
Beide onderweg20.480 bytes
Overgebleven ruimte45.056 bytes
Volledige limiet65.536 bytes
Elk onvoltooid keepalive-verzoek in de fetch group put uit dezelfde limiet van 65.536 bytes, dus de ruimte is wat er van de limiet over is na de verzoeken die al onderweg zijn.

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:

  1. Set corsMode to "cors".
  2. If contentType value is a CORS-safelisted request-header value for the Content-Type header, set corsMode to "no-cors".
  3. Append a Content-Type header 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 meegeeftContent-Type dat de browser insteltOp de CORS-safelistGevolg bij cross-origin
ArrayBuffer, TypedArray, DataViewgeengeen header verstuurdno-cors, geen preflight
Stringtext/plain;charset=UTF-8Jano-cors, geen preflight
URLSearchParamsapplication/x-www-form-urlencoded;charset=UTF-8Jano-cors, geen preflight
FormDatamultipart/form-data; boundary=...Jano-cors, geen preflight
Blob met type application/jsonapplication/jsonNeeCORS-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.

Iemand klapt een laptop dicht, het moment waarop een browsertabblad sluit en een beacon moet afgaan.

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.

Flowsery
Flowsery

Start je gratis proefperiode van 14 dagen

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.

VereistesendBeaconfetch keepalive
HTTP-methodeAlleen POSTElke methode
Eigen request-headersNiet ondersteundOndersteund
Controle over Content-TypeAfgeleid van het type bodyDoor jou ingesteld
ServerresponseNiet beschikbaarLeesbaar via de promise
Grootte van de bodyDeelt het budget van 64 KiBDeelt hetzelfde budget
Beschikbaar in service workersNeeJa

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.

Netwerkkabels in een serverrack, als beeld van het endpoint dat keepalive-verzoeken ontvangt.

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.

Flowsery
Flowsery

Start je gratis proefperiode van 14 dagen

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

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 overlevenWaarom beforeunload vs. pagehide bepaalt of je analytics overleven
Woordenlijst

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.

•6 min leestijd
Wat de bfcache doet met terugnavigaties en je aantal paginaweergavenWat de bfcache doet met terugnavigaties en je aantal paginaweergaven
Woordenlijst

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.

•8 min leestijd
Waarom CNAME-cloaking trackers niet meer verbergt voor Safari of BraveWaarom CNAME-cloaking trackers niet meer verbergt voor Safari of Brave
Woordenlijst

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.

•9 min leestijd
Hoe cookie syncing advertentie-ID's over websites heen koppeltHoe cookie syncing advertentie-ID's over websites heen koppelt
Woordenlijst

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.

•8 min leestijd
Zo bouw je berekende statistieken in GA4 binnen een quotum van vijf plekkenZo bouw je berekende statistieken in GA4 binnen een quotum van vijf plekken
Woordenlijst

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.

•8 min leestijd
Contentgroepering in GA4 instellen met één parameterContentgroepering in GA4 instellen met één parameter
Woordenlijst

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.

•8 min leestijd

Gerelateerde artikelen