diff --git a/files/en-us/web/api/deferredrequestinit/index.md b/files/en-us/web/api/deferredrequestinit/index.md
new file mode 100644
index 000000000000000..1ba560bbc7fef34
--- /dev/null
+++ b/files/en-us/web/api/deferredrequestinit/index.md
@@ -0,0 +1,63 @@
+---
+title: DeferredRequestInit
+slug: Web/API/DeferredRequestInit
+page-type: web-api-interface
+status:
+  - experimental
+browser-compat: api.Window.fetchLater
+---
+
+{{DefaultAPISidebar("fetchLater API")}}{{SeeCompatTable}}
+
+The **`DeferredRequestInit`** dictionary of the [`fetchLater()` API](/en-US/docs/Web/API/fetchLater_API) represents the set of options that can be used to configure a deferred fetch request.
+
+The `DeferredRequestInit` object is passed directly into the {{domxref("window.fetchLater()")}} function call as the second argument.
+
+## Instance properties
+
+This dictionary extends the {{domxref("RequestInit")}} dictionary with the addition of the following properties:
+
+- `activateAfter` {{optional_inline}}
+
+  - : A {{ domxref("DOMHighResTimeStamp") }} indicating a timeout in milliseconds after which the fetch request should be sent. The fetch can be sent earlier on navigating away. The _actual_ sending time is unknown, as the browser may wait for a longer or shorter time, for example, to optimize the batching of deferred fetches. If the `activateAfter` property is not provided, the deferred fetch waits until the end of the page visit (including entering the [bfcache](/en-US/docs/Glossary/bfcache)).
+
+### Exceptions
+
+- `RangeError` {{domxref("DOMException")}}
+  - : Raised when a negative `activateAfter` is provided.
+
+## Examples
+
+### Defer a `GET` request until the page is destroyed or enters the bfcache
+
+In this example, no `DeferredRequestInit` object is provided and no timeout is used:
+
+```js
+fetchLater("/send_beacon");
+```
+
+### Defer a `POST` request for around 1 minute
+
+In this example we create a {{domxref("Request")}}, and provide an `activateAfter` value to delay sending the request for 60,000 milliseconds (or one minute):
+
+```js
+fetchLater({
+  url: "/send_beacon"
+  method: "POST"
+  body: getBeaconData(),
+}, {activateAfter: 60000 /* 1 minute */});
+```
+
+> [!NOTE]
+> The actual sending time is unknown, as the browser may wait for a longer or shorter period of time, for example to optimize batching of deferred fetches.
+
+## Specifications
+
+{{Specifications}}
+
+## See also
+
+- [Using Fetch](/en-US/docs/Web/API/Fetch_API/Using_Fetch)
+- [ServiceWorker API](/en-US/docs/Web/API/Service_Worker_API)
+- [HTTP access control (CORS)](/en-US/docs/Web/HTTP/Guides/CORS)
+- [HTTP](/en-US/docs/Web/HTTP)
diff --git a/files/en-us/web/api/fetch_api/index.md b/files/en-us/web/api/fetch_api/index.md
index f4fd805c1be2de6..bfb555c00bfc853 100644
--- a/files/en-us/web/api/fetch_api/index.md
+++ b/files/en-us/web/api/fetch_api/index.md
@@ -23,7 +23,7 @@ You can create a request and response directly using the {{DOMxRef("Request.Requ
 
 Find out more about using the Fetch API features in [Using Fetch](/en-US/docs/Web/API/Fetch_API/Using_Fetch).
 
-## Fetch Interfaces
+## Interfaces
 
 - {{domxref("Window.fetch()")}} and {{domxref("WorkerGlobalScope.fetch()")}}
   - : The `fetch()` method used to fetch a resource.
diff --git a/files/en-us/web/api/fetchlater_api/fetchlater_quotas/index.md b/files/en-us/web/api/fetchlater_api/fetchlater_quotas/index.md
new file mode 100644
index 000000000000000..f382c5431d636f0
--- /dev/null
+++ b/files/en-us/web/api/fetchlater_api/fetchlater_quotas/index.md
@@ -0,0 +1,203 @@
+---
+title: fetchLater() quotas
+slug: Web/API/fetchLater_API/fetchLater_quotas
+page-type: guide
+status:
+  - experimental
+browser-compat:
+  - http.headers.Permissions-Policy.deferred-fetch
+  - http.headers.Permissions-Policy.deferred-fetch-minimal
+---
+
+{{DefaultAPISidebar("fetchLater API")}}{{SeeCompatTable}}
+
+Deferred [`fetchLater()` API](/en-US/docs/Web/API/fetchLater_API) fetches are batched and sent once the tab is closed. At this point, there is no way for the user to abort them. To avoid situations where documents abuse this bandwidth to send unlimited amounts of data over the network the API sets quotas on how much data can be deferred to be sent later.
+
+These quotas can be managed through {{HTTPHeader("Permissions-Policy/deferred-fetch", "deferred-fetch")}} and {{HTTPHeader("Permissions-Policy/deferred-fetch-minimal", "deferred-fetch-minimal")}} [Permissions Policy](/en-US/docs/Web/HTTP/Guides/Permissions_Policy) directives.
+
+## Overview
+
+The overall quota for `fetchLater()` is 640KiB per document. By default, this is divided into a 512KiB top-level quota and a 128KiB shared quota:
+
+- The 512KiB top-level quota by default is for any `fetchLater()` requests made from the top-level document and direct subframes using that origin.
+- The 128KiB shared quota by default is for any `fetchLater()` requests made in cross-origin subframes (for exmaple, `<iframe>`s, `<object>`s, `<embed>`s, and`<frame>`s).
+
+`fetchLater()` requests can be made to any URL and are not restricted to the same origin as the document or the subframe, so it's important to differentiate between requests made in the top-level document content (whether to first-party or third-party origins) and those made in subframes.
+
+For example, if a top-level `a.com` document includes a `<script>` that makes a `fetchLater()` request to `analytics.example.com`, this request would be bound by the top-level 512KiB limit. Alternatively, if the top-level document embeds an `<iframe>` with a source of `analytics.example.com` that makes a `fetchLater()` request, that request would be bound by the 128KiB limit.
+
+## Quota limits by reporting origin and subframe
+
+Only 64KiB of the top-level 512KiB quota can be used concurrently for the same reporting origin (the request URL's origin). This prevents third-party libraries from reserving quota opportunistically before they have data to send.
+
+Each cross-origin subframe gets an 8KiB quota out of the shared 128KiB quota by default, allocated when the subframe is added to the DOM (whether `fetchLater()` will be used in that subframe or not). This means that, in general, only the first 16 cross-origin subframes added to a page can use `fetchLater()` as they will use up the 128KiB quota.
+
+## Increasing subframe quotas by sharing the top-level quota
+
+The top-level origin can give selected cross-origin subframes an increased quota of 64KiB, taking it out of the larger top-level 512KiB limit. It does this by listing those origins in the {{HTTPHeader("Permissions-Policy/deferred-fetch", "deferred-fetch")}} Permissions Policy directive. This is allocated when the subframe is added to the DOM, leaving less quota for the top-level document and direct same-origin subframes. Multiple same-origin subdomains can each get a 64KiB quota.
+
+## Restricting the shared quota
+
+The top-level origin can also restrict the 128KiB shared quota to named cross-origin subframes by listing those origins in the {{HTTPHeader("Permissions-Policy/deferred-fetch-minimal", "deferred-fetch-minimal")}} Permissions Policy. It can also revoke the entire 128KiB default subframe quota and instead keep the full 640KiB quota for itself and any named `deferred-fetch` cross-origins by setting the {{HTTPHeader("Permissions-Policy/deferred-fetch-minimal", "deferred-fetch-minimal")}} Permissions Policy to `()`.
+
+## Delegating quotes to subframes of subframes
+
+By default, subframes of subframes are not allocated a quota and so cannot use `fetchLater()`. Subframes allocated the increased 64KiB quota can delegate the full 64KiB quota to further subframes and allow them to use `fetchLater()` by setting their own `deferred-fetch` Permissions Policy. They can only delegate their full quota to further subframes, not parts of it, and cannot specify new quotas. Subframes using the minimal 8KiB quota cannot delegate quotas to subframes. To be delegated quota, sub-subframes must be included in both the top-level and the subframe `deferred-fetch` {{httpheader('Permissions-Policy')}} directives.
+
+## When quotas are exceeded
+
+When quotas are exceeded, a `QuotaExceededError` is thrown when the {{domxref('Window.fetchLater()','fetchLater()')}} method is called to initiate the deferred request.
+
+Permissions Policy checks are not discernable from quota checks. Calling `fetchLater()` will throw a `QuotaExceededError` both if the quota is actually exceeded and if the quota was restricted for that origin via a Permissions Policy.
+
+Callers of `fetchLater()` should be defensive and catch `QuotaExceededError` errors in almost all cases, especially if they embed third-party JavaScript.
+
+## Examples
+
+### Using up the minimal quota
+
+```http
+Permissions-Policy: deferred-fetch=(self "https://b.com")
+```
+
+1. A `<iframe src="https://b.com/page">` receives 64KiB upon being added to the top-level document, from the top-level's 512KiB limit.
+2. A `<iframe src="https://c.com/page">` is not listed and so receives 8KiB upon being added to the top-level document from the 128KiB shared limit.
+3. 15 more cross-origin iframes would each receive 8KiB upon being added to the top-level document (similar to `c.com`).
+4. The next cross-origin iframe would not be granted any quota.
+5. If one of the cross-origin iframes is removed, its deferred fetches will be sent.
+6. The next cross-origin iframe _would_ receive an 8KiB quota, as there is quota available again.
+
+### RevokiRestricting the minimal quota to named origins
+
+```http
+Permissions-Policy: deferred-fetch-minimal=("https://b.com")
+```
+
+1. `<iframe src="https://b.com/page">` receives 8KiB upon being added to the top-level document.
+2. `<iframe src="https://c.com/page">` receives no quota upon being added to the top-level document.
+3. The top-level document and its same-origin descendants can use up to 512KiB.
+
+### Revoking the minimal quota altogether with top-level exceptions
+
+```http
+Permissions-Policy: deferred-fetch=(self "https://b.com")
+Permissions-Policy: deferred-fetch-minimal=()
+```
+
+1. `<iframe src="https://b.com/page">` receives 64KiB upon being added to the top-level document.
+2. `<iframe src="https://c.com/page">` receives no quota upon being added to the top-level document.
+3. The top-level document and its same-origin descendants can use up to the full 640KiB but that is reduced to 574KiB if a `b.com` subframe is created (or even less if multiple `b.com` subframes are created, each of which will be allocated a 64KiB quota).
+
+### Revoking the minimal quota altogether with no exceptions
+
+```http
+Permissions-Policy: deferred-fetch-minimal=()
+```
+
+1. The top-level document and its same-origin descendants can use up the full 640KiB.
+2. Subframes are not allocated any quota and cannot use `fetchLater()`.
+
+### Same-origin subframes share quota with the top-level and can delegate to subframes
+
+Assuming a top-level document on `a.com`, which embeds a subframe of `a.com`, which embeds a subframe of `b.com`, and no explicit Permission Policies.
+
+1. The top-level document of `a.com` has the default 512KiB quota.
+2. `<iframe src="https://a.com/embed">` shares the 512KiB quota upon being added to the top-level document.
+3. `<iframe src="https://b.com/embed">` receives an 8KiB quotaupon being added to the top-level document.
+
+### Same-origin subframes canot share quota with the top-level when separated by a cross-origin subframe
+
+Assuming a top-level document on `a.com`, which embeds a `<iframe src="https://b.com/">`, which embeds a subframe of `<iframe src="https://a.com/embed">`, and no explicit Permission Policies.
+
+1. The top-level document of `a.com` has the default 512KiB quota.
+2. `<iframe src="https://b.com/">` shares the 8KiB quota.
+3. `<iframe src="https://a.com/embed">` receives no quota; even though this is same-origin with the top origin, it is separated by a cross-origin.
+
+### Secondary subframes of subframes do not get quota by default
+
+Assuming a top-level document on `a.com`, which embeds a `<iframe src="https://b.com/">`, which embeds a `<iframe src="https://c.com/">`, and no explicit Permission Policies.
+
+1. The top-level frame of `a.com` has the default 512KiB quota.
+2. `<iframe src="https://b.com/">` receives 8KiB of the default shared quota.
+3. `<iframe src="https://c.com/">` receives no quota.
+
+### Granting the full quota to a further subframe
+
+Assuming a top-level document on `a.com`, which embeds a `<iframe src="https://b.com/">`, which embeds a `<iframe src="https://c.com/">`.
+
+Assuming that `a.com` has the following Permissions Policy:
+
+```http
+Permissions-Policy: deferred-fetch=("https://c.com" "https://c.com")
+```
+
+And, assuming that `b.com` has the following Permissions Policy:
+
+```http
+Permissions-Policy: deferred-fetch=("https://c.com")
+```
+
+1. The top-level frame of `a.com` has the default 512KiB quota.
+2. `<iframe src="https://b.com/">` receives 64KiB of the default quota.
+3. `<iframe src="https://b.com/">` delegates its full quota of 8KiB to `c.com`. `b.com` cannot use `fetchLater()`.
+4. `<iframe src="https://c.com/">` receives 8KiB of quota.
+
+### Redirects do not transfer quota
+
+Assuming a top-level document on `a.com`, which embeds a `<iframe src="https://b.com/">`, which redirects to `c.com`, and no explicit top-level Permission Policies.
+
+1. The top-level frame of `a.com` has the default 512KiB quota.
+2. `<iframe src="https://b.com/">` receives 8KiB of the default shared quota.
+3. The 8KiB is not transferred to `c.com` when `<iframe src="https://b.com/">` redirects to there, but the 8KiB is not released.
+
+### Redirects of subframes back to the top-level origin allow use of the top-level quota
+
+Assuming a top-level document on `a.com`, which embeds a `<iframe src="https://b.com/">`, which redirects to `a.com`, and no explicit top-level Permission Policies.
+
+1. The top-level frame of `a.com` has the default 512KiB quota.
+2. `<iframe src="https://b.com/">` receives 8KiB of the default shared quota.
+3. The 8KiB is not transferred to `a.com` when `<iframe src="https://b.com/">` redirects to there, but it is able to share the full top-level quota again, and the 8KiB is released.
+
+### Examples which throw a `QuotaExceededError`
+
+```js
+// Maximum of 64KiB per origin
+fetchLater(a_72_kb_url);
+
+// Maximum of 64KiB per origin including headers
+fetchLater("https://origin.example.com", { headers: headers_exceeding_64kb });
+
+// Maximum of 64KiB per origin including body and headers
+fetchLater(a_32_kib_url, { headers: headers_exceeding_32kib });
+
+// Maximum of 64KiB per origin including body
+fetchLater("https://origin.example.com", {
+  method: "POST",
+  body: body_exceeding_64_kib,
+});
+
+// Maximum of 64KiB per origin including body and automatically added headers
+fetchLater(a_62_kib_url /* with a 3kb referrer */);
+```
+
+### Examples which eventually throw a `QuotaExceededError`
+
+In the following sequence, contained in the top-level document, the first two requests would succeed, but the third would throw. That's because, even though the overall 640KiB quota was not exceeded, the third request exceeds the reporting-origin quota for `https://a.example.com` and would throw.
+
+```js
+fetchLater("https://a.example.com", { method: "POST", body: a_40kb_body });
+fetchLater("https://b.example.com", { method: "POST", body: a_40kb_body });
+fetchLater("https://a.example.com", { method: "POST", body: a_40kb_body });
+```
+
+## Specifications
+
+{{Specifications}}
+
+## Browser compatibility
+
+{{Compat}}
+
+## See also
+
+- [`fetchLater()` API](/en-US/docs/Web/API/fetchLater_API)
diff --git a/files/en-us/web/api/fetchlater_api/index.md b/files/en-us/web/api/fetchlater_api/index.md
new file mode 100644
index 000000000000000..8f67ba008af032d
--- /dev/null
+++ b/files/en-us/web/api/fetchlater_api/index.md
@@ -0,0 +1,75 @@
+---
+title: fetchLater() API
+slug: Web/API/fetchLater_API
+page-type: web-api-overview
+status:
+  - experimental
+browser-compat: api.Window.fetchLater
+---
+
+{{DefaultAPISidebar("fetchLater API")}}{{SeeCompatTable}}
+
+The **`fetchLater()` API** provides an interface to request a deferred fetch that can be sent after a specified period of time, or when the page is closed or navigated away from.
+
+## Concepts and usage
+
+Developers often need to send (or beacon) data back to the server, particularly at the end of a user's visit to a page — for example, for analytics services. There are several ways to do this: from adding 1 pixel {{HTMLElement("img")}} elements to the page, to {{domxref("XMLHttpRequest")}}, to the dedicated {{domxref("Beacon API", "Beacon API", "", "nocode")}}, and the {{domxref("Fetch API", "Fetch API", "", "nocode")}} itself.
+
+The issue is that all of these methods suffer from reliability problems for end-of-visit beaconing. While the Beacon API and the {{domxref("Request.keepalive", "keepalive")}} property of the Fetch API will send data, even if the document is destroyed (to the best efforts that can be made in this scenario), this only solves part of the problem.
+
+The other — more difficult — part to solve concerns deciding _when_ to send the data, since there is not an ideal time in a page's lifecycle to make the JavaScript call to send out the beacon:
+
+- The {{domxref("Window.unload_event", "unload")}} and {{domxref("Window.beforeunload_event", "beforeunload")}} events are unreliable, and outright ignored by several major browsers.
+- The {{domxref("Window.pagehide_event", "pagehide")}} and {{domxref("document.visibilitychange_event", "visibilitychange")}} events are more reliable, but still have issues on mobile platforms.
+
+This means developers looking to reliably send out data via a beacon need to do so more frequently than is ideal. For example, they may send a beacon on each change, even if the final value for the page has not yet been reached. This has costs in network usage, server processing, and merging or discarding outdated beacons on the server.
+
+Alternatively, developers can choose to accept some level of missing data — either by:
+
+- Beaconing after a designated cut-off time and not collecting later data.
+- Beaconing at the end of the page lifecycle but accepting that sometimes this will not be reliable.
+
+The `fetchLater()` API extends the {{domxref("Fetch API")}} to allow setting fetch requests up in advance. These deferred fetches can be updated before they have been sent, allowing the payload to reflect the latest data to be beaconed.
+
+The browser then sends the beacon when the tab is closed or navigated away from, or after a set time if specified. This avoids sending multiple beacons but still ensures a reliable beacon within reasonable expectations (i.e., excluding when the browser process shuts down unexpectedly during a crash).
+
+Deferred fetches can also be aborted using an {{domxref("AbortController")}} if they are no longer required, avoiding further unnecessary costs.
+
+### Quotas
+
+Deferred fetches are batched and sent once the tab is closed; at this point, there is no way for the user to abort them. To avoid situations where documents abuse this bandwidth to send unlimited amounts of data over the network, the overall quota for a top-level document is capped at 640KiB.
+
+Callers of `fetchLater()` should be defensive and catch `QuotaExceededError` errors in almost all cases, especially if they embed third-party JavaScript.
+
+Since this cap makes deferred fetch bandwidth a scarce resource, which needs to be shared between multiple reporting origins (for example, several RUM libraries) and subframes from multiple origins, the platform provides a reasonable default division of this quota. In addition, it provides {{HTTPHeader("Permissions-Policy/deferred-fetch", "deferred-fetch")}} and {{HTTPHeader("Permissions-Policy/deferred-fetch-minimal", "deferred-fetch-minimal")}} [Permissions Policy](/en-US/docs/Web/HTTP/Guides/Permissions_Policy) directives to allow dividing it differently when desired.
+
+See [fetchLater() quotas](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas) for more details and examples.
+
+## Interfaces
+
+- {{domxref("Window.fetchLater()")}}
+  - : Used to queue a resource for sending at a later point.
+- {{domxref("DeferredRequestInit")}}
+  - : Represents the set of options that can be used to configure a deferred fetch request.
+- {{domxref("FetchLaterResult")}}
+  - : Represents the result of requesting a deferred fetch.
+
+## HTTP headers
+
+- {{HTTPHeader("Permissions-Policy/deferred-fetch", "deferred-fetch")}}
+  - : Controls [top-level quota](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas) for the `fetchLater()` API.
+- {{HTTPHeader("Permissions-Policy/deferred-fetch-minimal", "deferred-fetch-minimal")}}
+  - : Controls [shared cross-origin subframe quota](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas) for the `fetchLater()` API.
+
+## Specifications
+
+{{Specifications}}
+
+## Browser compatibility
+
+{{Compat}}
+
+## See also
+
+- [`fetchLater()` quotas](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas)
+- [Fetch API](/en-US/docs/Web/API/Fetch_API)
diff --git a/files/en-us/web/api/fetchlaterresult/activated/index.md b/files/en-us/web/api/fetchlaterresult/activated/index.md
new file mode 100644
index 000000000000000..f049356e181f11e
--- /dev/null
+++ b/files/en-us/web/api/fetchlaterresult/activated/index.md
@@ -0,0 +1,41 @@
+---
+title: "FetchLaterResult: activated property"
+short-title: activated
+slug: Web/API/FetchLaterResult/activated
+page-type: web-api-instance-property
+status:
+  - experimental
+browser-compat: api.FetchLaterResult.activated
+---
+
+{{DefaultAPISidebar("fetchLater API")}}{{SeeCompatTable}}
+
+The **`activated`** read-only property of the {{domxref("FetchLaterResult")}} interface returns a boolean specifying whether the deferred fetch has been sent.
+
+## Value
+
+A {{jsxref('Boolean')}}.
+
+## Examples
+
+### Defer a `POST` request for around one minute and create a function to check if sent
+
+```js
+const result = fetchLater("https://report.example.com", {
+  method: "POST",
+  body: JSON.stringify(myReport),
+  activateAfter: 60000 /* 1 minute */,
+});
+
+function check_if_fetched() {
+  return result.activated;
+}
+```
+
+## Specifications
+
+{{Specifications}}
+
+## Browser compatibility
+
+{{Compat}}
diff --git a/files/en-us/web/api/fetchlaterresult/index.md b/files/en-us/web/api/fetchlaterresult/index.md
new file mode 100644
index 000000000000000..d3f4456e492e323
--- /dev/null
+++ b/files/en-us/web/api/fetchlaterresult/index.md
@@ -0,0 +1,50 @@
+---
+title: FetchLaterResult
+slug: Web/API/FetchLaterResult
+page-type: web-api-interface
+status:
+  - experimental
+browser-compat: api.FetchLaterResult
+---
+
+{{DefaultAPISidebar("fetchLater API")}}{{SeeCompatTable}}
+
+The **`FetchLaterResult`** interface of the [`fetchLater()` API](/en-US/docs/Web/API/fetchLater_API) is returned by the {{domxref("Window.FetchLater()")}} method after a deferred fetch has been created.
+
+It contains a single `activated` property that indicates whether the deferred request has been sent out or not.
+
+After a successful sending, the whole response is ignored — including body and headers — so the response of the deferred fetch is never returned to the `FetchLaterResult` interface.
+
+## Instance properties
+
+- {{domxref('FetchLaterResult.activated')}} {{ReadOnlyInline}} {{Experimental_Inline}}
+  - : A read-only boolean field that indicates whether the deferred request has been sent out. This is initially set to `false` and will then be updated by the browser once the deferred fetch has been sent.
+
+## Examples
+
+### Defer a `POST` request for around one minute and create a function to check if sent
+
+```js
+const result = fetchLater("https://report.example.com", {
+  method: "POST",
+  body: JSON.stringify(myReport),
+  activateAfter: 60000 /* 1 minute */,
+});
+
+function check_if_fetched() {
+  return result.activated;
+}
+```
+
+## Specifications
+
+{{Specifications}}
+
+## Browser compatibility
+
+{{Compat}}
+
+## See also
+
+- {{domxref("fetchLater() API")}}
+- [Fetch API](/en-US/docs/Web/API/Fetch_API)
diff --git a/files/en-us/web/api/window/fetchlater/index.md b/files/en-us/web/api/window/fetchlater/index.md
new file mode 100644
index 000000000000000..1c87cf5d26afcfc
--- /dev/null
+++ b/files/en-us/web/api/window/fetchlater/index.md
@@ -0,0 +1,187 @@
+---
+title: "Window: fetchLater() method"
+short-title: fetchLater()
+slug: Web/API/Window/fetchLater
+page-type: web-api-instance-method
+status:
+  - experimental
+browser-compat: api.Window.fetchLater
+---
+
+{{APIRef("fetchLater API")}}{{SeeCompatTable}}
+
+The **`fetchLater()`** method of the {{domxref("Window")}} interface creates a deferred fetch.
+
+A `fetchLater()` request is sent once the page is navigated away from (it is destroyed or enters the [bfcache](/en-US/docs/Glossary/bfcache)), or after a provided `activateAfter` timeout — whichever comes first.
+
+The `fetchLater()` methods returns a {{domxref("FetchLaterResult")}} object containing a single `activated` value stating whether the request has been sent yet. Note the method does not return the result of the actual fetch when that happens (since it is often sent after the document has been destroyed) and the whole response of the fetch, including body and headers, is ignored.
+
+Requests whose body is a {{domxref("ReadableStream")}} cannot be deferred.
+
+The `fetchLater()` method is controlled by the `connect-src` [Content Security Policy](/en-US/docs/Web/HTTP/Reference/Headers/Content-Security-Policy) directive rather than the directive of the retrieved resources.
+
+## Syntax
+
+```js-nolint
+fetchLater(resource)
+fetchLater(resource, options)
+```
+
+### Parameters
+
+The `fetchLater()` method takes all the same parameters as {{domxref("Window.fetch", "fetch()")}}, but with one additional `activateAfter` option.
+
+- `resource`
+
+  - : This defines the resource that you wish to fetch. Identical to {{domxref("Window.fetch", "fetch()")}}, this can either be:
+
+    - A string or any other object with a {{Glossary("stringifier")}} — including a {{domxref("URL")}} object — that provides the URL of the resource you want to fetch. The URL may be relative to the base URL, which is the document's {{domxref("Node.baseURI", "baseURI")}} in a window context.
+    - A {{domxref("Request")}} object.
+
+- `options` {{optional_inline}}
+
+  - : A {{domxref("DeferredRequestInit")}} object containing any custom settings that you want to apply to the request, including an `activateAfter` timeout value that defines how long the result should be deferred for before sending.
+
+### Exceptions
+
+The [same exceptions for `fetch()`](/en-US/docs/Web/API/Window/fetch#exceptions) can be raised for `fetchLater()`, along with the following additional exceptions:
+
+- `QuotaExceededError` {{domxref("DOMException")}}
+
+  - : Use of this feature was blocked due to exceeding the available quota. See [`fetchLater()` quotas](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas) for more details. Callers of `fetchLater()` should be defensive and catch `QuotaExceededError` errors in almost all cases, especially if they are embedding third-party JavaScript.
+
+- `RangeError` {{domxref("DOMException")}}
+
+  - : Thrown when a negative `activateAfter` value is specified.
+
+- `TypeError` {{domxref("DOMException")}}
+  - : In addition to the reasons for `fetch()`, this exception will also be thrown for a {{domxref("ReadableStream")}} request (which cannot be deferred) or for use of untrustworthy URLs (such as `http://`).
+
+### Return value
+
+A {{domxref("FetchLaterResult")}} containing an `activated` boolean property indicating if the request has been sent yet.
+
+> [!NOTE]
+> Once the fetch request is sent, its response — including the body and headers — is not made available and will be ignored.
+
+## Examples
+
+The [`fetchLater()` quotas](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas) article provides examples of how the quotas are applied.
+
+### Defer a `GET` request until the page is navigated away from or closed
+
+```js
+fetchLater("/send_beacon");
+```
+
+### Defer a `POST` request for around one minute
+
+In this example we create a {{domxref("Request")}}, and provide an `activateAfter` value to delay sending the request for 60,000 milliseconds (or one minute):
+
+```js
+fetchLater({
+  url: "/send_beacon"
+  method: "POST"
+  body: getBeaconData(),
+}, {activateAfter: 60000 /* 1 minute */});
+```
+
+> [!NOTE]
+> The actual sending time is unknown, as the browser may wait for a longer or shorter period of time, for example to optimize batching of deferred fetches.
+
+### Defer a `POST` request for around one minute with a try/catch
+
+The same example as above, but the best practice is to enclose this in a try/catch:
+
+```js
+try {
+  fetchLater({
+    url: "/send_beacon"
+    method: "POST"
+    body: getBeaconData(),
+  }, {activateAfter: 60000 /* 1 minute */});
+} catch (e) {
+  if (e instanceOf QuotaExceededError) {
+    // Handle the quota error
+  } else {
+    // Handle other errors
+  }
+}
+```
+
+### Defer a `POST` request for around one minute and create a function to check if sent
+
+```js
+const result = fetchLater("https://report.example.com", {
+  method: "POST",
+  body: JSON.stringify(myReport),
+  activateAfter: 60000 /* 1 minute */,
+});
+
+function check_if_fetched() {
+  return result.activated;
+}
+```
+
+### Update a pending request
+
+In this example we use an {{domxref("AbortController")}} to cancel and recreate the request:
+
+```js
+let beaconResult = null;
+let beaconAbort = null;
+
+function updateBeacon(data) {
+  const pending = !beaconResult || !beaconResult.activated;
+  if (pending && beaconAbort) {
+    beaconAbort.abort();
+  }
+
+  createBeacon(data);
+}
+
+function createBeacon(data) {
+  if (beaconResult && !beaconResult.activated) {
+    // Avoid creating duplicated beacon if the previous one is still pending.
+    return;
+  }
+
+  beaconAbort = new AbortController();
+  beaconResult = fetchLater({
+    url: data
+    signal: beaconAbort.signal
+  });
+}
+```
+
+### Invalid examples
+
+Any of the following calls to `fetchLater()` would throw:
+
+```js
+// Only potentially trustworthy URLs are supported
+fetchLater("http://untrusted.example.com");
+
+// The length of the deferred request has to be known
+fetchLater("https://origin.example.com", { body: someDynamicStream });
+
+// Deferred fetching only works on active windows
+const detachedWindow = iframe.contentWindow;
+iframe.remove();
+detachedWindow.fetchLater("https://origin.example.com");
+```
+
+## Specifications
+
+{{Specifications}}
+
+## Browser compatibility
+
+{{Compat}}
+
+## See also
+
+- [`fetchLater()` API](/en-US/docs/Web/API/fetchLater_API)
+- [`fetchLater()` quotas](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas)
+- {{domxref("FetchLaterResult")}}
+- [Fetch API](/en-US/docs/Web/API/Fetch_API)
diff --git a/files/en-us/web/http/reference/headers/content-security-policy/connect-src/index.md b/files/en-us/web/http/reference/headers/content-security-policy/connect-src/index.md
index 2b165cfe13d627c..0d6233b0b00d195 100644
--- a/files/en-us/web/http/reference/headers/content-security-policy/connect-src/index.md
+++ b/files/en-us/web/http/reference/headers/content-security-policy/connect-src/index.md
@@ -13,6 +13,7 @@ loaded using script interfaces. The following APIs are controlled by this direct
 
 - The [`ping`](/en-US/docs/Web/HTML/Element/a#ping) attribute in {{htmlelement("a")}} elements
 - {{domxref("Window/fetch", "fetch()")}}
+- {{domxref("Window/fetchLater", "fetchLater()")}} {{experimental_inline}}
 - {{domxref("XMLHttpRequest")}}
 - {{domxref("WebSocket")}}
 - {{domxref("EventSource")}}
diff --git a/files/en-us/web/http/reference/headers/permissions-policy/deferred-fetch-minimal/index.md b/files/en-us/web/http/reference/headers/permissions-policy/deferred-fetch-minimal/index.md
new file mode 100644
index 000000000000000..20a3f4b18a67338
--- /dev/null
+++ b/files/en-us/web/http/reference/headers/permissions-policy/deferred-fetch-minimal/index.md
@@ -0,0 +1,97 @@
+---
+title: "Permissions-Policy: deferred-fetch-minimal"
+slug: Web/HTTP/Reference/Headers/Permissions-Policy/deferred-fetch-minimal
+page-type: http-permissions-policy-directive
+status:
+  - experimental
+browser-compat: http.headers.Permissions-Policy.deferred-fetch-minimal
+---
+
+{{HTTPSidebar}}{{SeeCompatTable}}
+
+The `deferred-fetch` and {{HTTPHeader("Permissions-Policy/deferred-fetch-minimal", "deferred-fetch-minimal")}} {{HTTPHeader("Permissions-Policy")}} directives are part of the [`fetchLater()` API](/en-US/docs/Web/API/fetchLater_API).
+
+They determine how the overall 640KiB quota limit is distributed between the top-level origin and its cross-origin subframes. By default, the top-level origin is granted 512KiB, and each cross-origin subframe is granted 8KiB out of the remaining 128KiB. The `deferred-fetch-minimal` Permissions Policy can also block all origins; this will reallocate the 128KiB shared limit to the top-level quota, giving it access to the full 640KiB limit.
+
+See [`fetchLater()` quotas](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas) guide for more details and examples.
+
+## Syntax
+
+```http
+Permissions-policy: deferred-fetch-minimal=*
+Permissions-policy: deferred-fetch-minimal=()
+Permissions-policy: deferred-fetch-minimal=(self)
+Permissions-policy: deferred-fetch-minimal=(<urllist>)
+```
+
+- `<urllist>`
+  - : A space-separated list of origins that are allowed to use the secondary 128KiB quota (with a maximum of 8KiB per subframe).
+
+A top-level frame with the `deferred-fetch-minimal` permission set to `self` or `()` does not allowed the default shared 128kb quota to be used by cross-origin subframes at all. Instead, the 128KiB quota for subframes is added to its normal quota.
+
+## Default policy
+
+The default allowlist for `deferred-fetch-minimal` is `*`.
+
+## Examples
+
+See [`fetchLater()` quotas](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas) for more examples.
+
+### Using up the minimal quota
+
+```http
+Permissions-Policy: deferred-fetch=(self "https://b.com")
+```
+
+1. A subframe of `b.com` receives 64KiB upon creation, from the top-level's 512KiB limit.
+2. A subframe of `c.com` is not listed and so receives 8KiB upon creation from the 128KiB shared limit.
+3. 15 more subframes would receive 8KiB upon creation (similar to `c.com`, and another `c.com` subframe would also receive another 8KiB quota).
+4. The next subframe would not be granted any quota.
+5. If one of the subframes is removed, its deferred fetches will be sent.
+6. The next subframe would receive an 8KiB quota, as there is quota available again.
+
+## Revoking the minimal quota altogether with exceptions
+
+```http
+Permissions-Policy: deferred-fetch=(self "https://b.com")
+Permissions-Policy: deferred-fetch-minimal=()
+```
+
+1. A subframe of `b.com` receives 64KiB upon creation.
+2. A subframe of `c.com` receives no quota upon creation.
+3. The top-level document and its same-origin descendants can use up to the full 640KiB, but that is reduced to 574KiB if a `b.com` subframe is created.
+
+## Revoking the minimal quota altogether with no exceptions
+
+```http
+Permissions-Policy: deferred-fetch-minimal=()
+```
+
+1. The top-level document and its same-origin descendants can use up the full 640KiB.
+2. Subframes are not allocated any quota and cannot use `fetchLater()`.
+
+## Restricting the minimal quota to named origins
+
+```http
+Permissions-Policy: deferred-fetch=(self "https://b.com")
+Permissions-Policy: deferred-fetch-minimal=("https://c.com")
+```
+
+1. A subframe of `b.com` receives 64KiB upon creation.
+2. A subframe of `c.com` receives 8KiB upon creation.
+3. A subframe of `d.com` receives no quota upon creation.
+
+## Specifications
+
+{{Specifications}}
+
+## Browser compatibility
+
+{{Compat}}
+
+## See also
+
+- [`fetchLater()` quotas](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas)
+- [`fetchLater()` API](/en-US/docs/Web/API/fetchLater_API)
+- {{HTTPHeader("Permissions-Policy")}} header
+- [Permissions Policy](/en-US/docs/Web/HTTP/Guides/Permissions_Policy)
diff --git a/files/en-us/web/http/reference/headers/permissions-policy/deferred-fetch/index.md b/files/en-us/web/http/reference/headers/permissions-policy/deferred-fetch/index.md
new file mode 100644
index 000000000000000..11d4f7ce6d5aac9
--- /dev/null
+++ b/files/en-us/web/http/reference/headers/permissions-policy/deferred-fetch/index.md
@@ -0,0 +1,78 @@
+---
+title: "Permissions-Policy: deferred-fetch"
+slug: Web/HTTP/Reference/Headers/Permissions-Policy/deferred-fetch
+page-type: http-permissions-policy-directive
+status:
+  - experimental
+browser-compat: http.headers.Permissions-Policy.deferred-fetch
+---
+
+{{HTTPSidebar}}{{SeeCompatTable}}
+
+The `deferred-fetch` and {{HTTPHeader("Permissions-Policy/deferred-fetch-minimal", "deferred-fetch-minimal")}} {{HTTPHeader("Permissions-Policy")}} directives are part of the [`fetchLater()` API](/en-US/docs/Web/API/fetchLater_API).
+
+They determine how the overall 640KiB quota limit is distributed between the top-level origin and its cross-origin subframes. By default, the top-level origin is granted 512KiB, and each cross-origin subframe is granted 8KiB out of the rest of the 128KiB. The `deferred-fetch` Permissions Policy can allow sub-frame origins to be granted a larger 64KiB quota out of the top-level 512KiB quota in place of the 8KiB minimal quota they would otherwise receive by default.
+
+See [`fetchLater()` quotas](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas) for more details and examples.
+
+## Syntax
+
+```http
+Permissions-policy: deferred-fetch=(self)
+Permissions-policy: deferred-fetch=(self <urllist>)
+Permissions-policy: deferred-fetch=(<urllist>)
+```
+
+- `<urllist>`
+  - : A space-separated list of origins (each of which is given in quotation marks) which are granted a higher quota of 64KiB taken from the parent's main quota. The 64KiB quota is taken at the time the subframe is created.
+
+A cross-origin subframe can grant `deferred-fetch` to one of its cross-origin subframe descendants, delegating its entire quota. This only works if none of the quota is currently being used.
+
+Permissions Policy checks are not discernable from quota checks. Calling `fetchLater()` will throw a `QuotaExceededError` both if the quota is actually exceeded and if the quota was restricted for that origin via a Permissions Policy.
+
+## Default policy
+
+The default allowlist for `deferred-fetch` is `self`.
+
+## Examples
+
+See [`fetchLater()` quotas](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas) for more examples.
+
+### Using up the minimal quota
+
+```http
+Permissions-Policy: deferred-fetch=(self "https://b.com")
+```
+
+1. A subframe of `b.com` receives 64KiB upon creation, from the top-level's 512KiB limit.
+2. A subframe of `c.com` is not listed and so receives 8KiB upon creation from the 128KiB shared limit.
+3. 15 more subframes of different origins would receive 8KiB upon creation (similar to `c.com`).
+4. The next subframe would not be granted any quota.
+5. If one of the subframes is removed, its deferred fetches will be sent.
+6. The next subframe would receive an 8KiB quota, as there is quota available again.
+
+## Revoking the minimal quota altogether
+
+```http
+Permissions-Policy: deferred-fetch=(self "https://b.com")
+Permissions-Policy: deferred-fetch-minimal=()
+```
+
+1. A subframe of `b.com` receives 64KiB upon creation.
+2. A subframe of `c.com` receives no quota upon creation.
+3. The top-level document and its same-origin descendants can use up to the full 640KiB, but that is reduced to 574KiB if a `b.com` subframe is created.
+
+## Specifications
+
+{{Specifications}}
+
+## Browser compatibility
+
+{{Compat}}
+
+## See also
+
+- [`fetchLater()` quotas](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas)
+- [`fetchLater()` API](/en-US/docs/Web/API/fetchLater_API)
+- {{HTTPHeader("Permissions-Policy")}} header
+- [Permissions Policy](/en-US/docs/Web/HTTP/Guides/Permissions_Policy)
diff --git a/files/en-us/web/http/reference/headers/permissions-policy/index.md b/files/en-us/web/http/reference/headers/permissions-policy/index.md
index a17d259b018b106..1fed50280cd054e 100644
--- a/files/en-us/web/http/reference/headers/permissions-policy/index.md
+++ b/files/en-us/web/http/reference/headers/permissions-policy/index.md
@@ -109,6 +109,14 @@ You can specify
 
   - : Controls whether the current document can be treated as {{domxref("Window.crossOriginIsolated", "cross-origin isolated", "", 1)}}.
 
+- {{HTTPHeader('Permissions-Policy/deferred-fetch', 'deferred-fetch')}} {{experimental_inline}}
+
+  - : Controls the allocation of the top-level origin's [`fetchLater()` quota](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas).
+
+- {{HTTPHeader('Permissions-Policy/deferred-fetch-minimal', 'deferred-fetch-minimal')}} {{experimental_inline}}
+
+  - : Controls the allocation of the shared cross-origin subframe [`fetchLater()` quota](/en-US/docs/Web/API/fetchLater_API/fetchLater_quotas).
+
 - {{HTTPHeader('Permissions-Policy/display-capture', 'display-capture')}} {{experimental_inline}}
 
   - : Controls whether or not the current document is permitted to use the {{domxref("MediaDevices.getDisplayMedia", "getDisplayMedia()")}} method to capture screen contents. When this policy is disabled, the promise returned by `getDisplayMedia()` will reject with a `NotAllowedError` {{DOMxRef("DOMException")}} if permission is not obtained to capture the display's contents.
diff --git a/files/jsondata/GroupData.json b/files/jsondata/GroupData.json
index 0db51b8c64b1634..8eaba339b85cfec 100644
--- a/files/jsondata/GroupData.json
+++ b/files/jsondata/GroupData.json
@@ -532,6 +532,14 @@
       "properties": [],
       "events": []
     },
+    "fetchLater API": {
+      "overview": ["fetchLater API"],
+      "guides": ["/docs/Web/API/fetchLater_API/fetchLater_quotas"],
+      "interfaces": ["DeferredRequestInit", "FetchLaterResult"],
+      "methods": ["Window.fetchLater()"],
+      "properties": [],
+      "events": []
+    },
     "Fenced Frame API": {
       "overview": ["Fenced Frame API"],
       "guides": [