Test your knowledge: The 64 KiB Quota

Question 1 of 6

How is the keepalive quota actually shaped?

The famous '64 + 256' figure appears in neither spec.

Answer options A 64 KB per request plus 256 KB aggregate per page B ONE 64 KiB (65,536-byte) shared in-flight pool per fetch group C 64 KiB per origin, enforced by the server D Unlimited for beacons under 1 KiB

The Fetch spec defines a single 64 kibibyte in-flight keepalive pool per fetch group. The '256 KB aggregate limit' circulating in tutorials is a myth — the spec mentions no such second number.

Review this lesson

Question 2 of 6

What does the quota accounting charge against the pool?

That is why the practical recipe reserves a safety margin.

Answer options A Body bytes only B Body bytes plus an estimate of the headers the user agent will send C Body bytes plus the response size D The compressed transfer size

Fetch's transmit step charges the request body bytes plus a header estimate. Chrome measures Blob.size plus roughly 256 bytes of allowance — so budgeting exactly 65,536 body bytes fails. The recipe's quota-queue uses 64 KiB minus a 1 KiB safety margin.

Review this lesson

Question 3 of 6

When does a beacon release its quota charge?

Sequential beacons each under the limit are fine; it is bursts that collide.

Answer options A When the page's unload completes B When the request completes — the quota limits in-flight requests, not lifetime totals C Never — the charge persists until the tab closes D After 30 seconds, regardless of completion

The pool is refilled as requests complete. Ten 7 KiB beacons sent sequentially all succeed; ten sent simultaneously as one burst exceed the pool together. The quota is concurrency-shaped, not volume-shaped.

Review this lesson

Question 4 of 6

`sendBeacon` returns `false` only when…

Everything after queueing is invisible to the caller by design.

Answer options A the network is unreachable B the quota check fails at queueing time C the server responds 4xx/5xx D the page is already hidden

The boolean mirrors one question: did the request enter the fetch group's keepalive request list? Quota overflow is the only synchronous failure that returns false. Network errors, CORS failures, and server errors all happen after the boolean has already been returned.

Review this lesson

Question 5 of 6

Why does `sendBeacon(url, stream)` fail with a `TypeError` in every browser?

The quota must be charged upfront; you cannot charge what you cannot measure.

Answer options A ReadableStream bodies have unknown length, and keepalive requests must have a known length B Streams are not part of BodyInit C Streams cannot cross the document boundary D It works — but only in Chrome

A keepalive request's byte length must be known at queueing time to charge the quota. A ReadableStream's length is unknowable up front, so Fetch rejects it: 'Cannot use a ReadableStream body with keepalive: true'. Buffer the stream into a Blob or string first.

Review this lesson

Question 6 of 6

What does the `quota-queue.js` recipe provide?

When the pool is momentarily full, the answer is patience, not bigger payloads.

Answer options A A server-side rate limiter for beacon endpoints B A client queue that waits for pool space and retries refused beacons C A shim that raises the quota to 256 KB D A compression layer that shrinks payloads under the limit

The quota queue tracks in-flight charges, refuses nothing permanently, and re-attempts refused beacons as earlier requests complete and release their quota — turning transient false returns into eventual sends.

Review this lesson

Test your knowledge: The 64 KiB Quota