# WebTransport glossary

URL: https://webtransport.day/glossary/
Checked: 2026-10-28

## 0-RTT

A QUIC and TLS 1.3 feature that lets a returning client send application data in its very first flight, before the handshake finishes, by reusing parameters from an earlier connection. That early data can be replayed by an attacker.

Because of replay risk, clients should only send 0-RTT data when the application explicitly asks for it, and it should never trigger actions with unwanted side effects.

Sources: [RFC 9001: Using TLS to Secure QUIC](https://www.rfc-editor.org/rfc/rfc9001.html); [RFC 8446: The Transport Layer Security (TLS) Protocol Version 1.3](https://www.rfc-editor.org/rfc/rfc8446.html)

## ALPN

A TLS extension that lets client and server agree, during the handshake, on which application protocol will run over the encrypted connection. HTTP/3 is identified by the ALPN token "h3".

The client sends its protocols in preference order and the server picks exactly one. If none match, the server aborts with the fatal no_application_protocol alert.

Sources: [RFC 7301: TLS Application-Layer Protocol Negotiation Extension](https://www.rfc-editor.org/rfc/rfc7301.html); [RFC 9114: HTTP/3](https://www.rfc-editor.org/rfc/rfc9114.html)

## Backpressure

A signal that flows backward through a chain of streams, telling the producer to slow down because the consumer cannot keep up. In the Streams API it is expressed through a queue's desiredSize.

desiredSize is the high water mark minus the size of queued chunks. MDN notes the WebSocket API has no way to apply backpressure, which is one reason stream-based APIs such as WebTransport are attractive.

Sources: [Streams Standard (WHATWG)](https://streams.spec.whatwg.org/); [Streams API concepts (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Concepts); [WebSocket (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket)

## Bidirectional stream

An ordered, reliable byte channel in which both endpoints can send data. In the browser, WebTransport exposes one as a WebTransportBidirectionalStream with a readable side for incoming bytes and a writable side for outgoing bytes.

Either side can open one: call createBidirectionalStream() to open it, or read incomingBidirectionalStreams for those the server opens.

Sources: [WebTransportBidirectionalStream (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransportBidirectionalStream); [draft-ietf-webtrans-overview-13: The WebTransport Protocol Framework](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-overview); [RFC 9000: QUIC: A UDP-Based Multiplexed and Secure Transport](https://www.rfc-editor.org/rfc/rfc9000.html)

## Capsule

A type-length-value message defined by the HTTP Capsule Protocol and carried inside the data stream of an upgraded HTTP request, such as an Extended CONNECT. Receivers silently skip capsule types they do not recognise.

The DATAGRAM capsule (type 0x00) carries an HTTP Datagram when QUIC DATAGRAM frames are unavailable. The WebTransport over HTTP/3 draft defines its own capsules, including WT_CLOSE_SESSION and WT_DRAIN_SESSION.

Sources: [RFC 9297: HTTP Datagrams and the Capsule Protocol](https://www.rfc-editor.org/rfc/rfc9297.html); [draft-ietf-webtrans-http3-16: WebTransport over HTTP/3](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3-16)

## closeInfo / close codes

The dictionary passed to WebTransport.close(), holding a numeric closeCode (default 0) and a reason string. The closed promise later reports the same pair once the session ends.

The spec truncates the UTF-8 encoded reason to 1024 bytes, and the HTTP/3 draft likewise caps the close message at 1024 bytes. An abrupt failure rejects the closed promise instead of resolving it.

Sources: [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/); [WebTransport.close() (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/close); [WebTransport.closed (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/closed); [draft-ietf-webtrans-http3-16: WebTransport over HTTP/3](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3-16)

## Congestion control

The sender-side logic that limits how much unacknowledged data is in flight so a connection adapts to network capacity instead of overwhelming it. QUIC defaults to a NewReno-style controller but permits others, such as CUBIC.

QUIC datagrams are subject to the connection's congestion controller too: the sender must either delay a datagram until allowed or drop it.

Sources: [RFC 9002: QUIC Loss Detection and Congestion Control](https://www.rfc-editor.org/rfc/rfc9002.html); [RFC 9000: QUIC: A UDP-Based Multiplexed and Secure Transport](https://www.rfc-editor.org/rfc/rfc9000.html); [RFC 9221: An Unreliable Datagram Extension to QUIC](https://www.rfc-editor.org/rfc/rfc9221.html)

## congestionControl option

A WebTransport constructor option that hints whether the browser should tune its congestion control for throughput or low latency. Accepted values are "default", "throughput" and "low-latency"; the browser may ignore the hint.

The chosen preference can be read back from the congestionControl property. The spec flags "low-latency" as a feature at risk because no browser implements a low-latency algorithm yet.

Sources: [WebTransport() constructor (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/WebTransport); [WebTransport.congestionControl (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/congestionControl); [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/)

## Connection ID

An identifier carried in QUIC packets that names a connection independently of IP addresses and ports, so packets still reach the right endpoint when the network path changes, such as moving from Wi-Fi to mobile data.

Each endpoint chooses the connection IDs its peer will use to address it.

Sources: [RFC 9000: QUIC: A UDP-Based Multiplexed and Secure Transport](https://www.rfc-editor.org/rfc/rfc9000.html); [WebTransport API (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport_API)

## Datagram

A small, self-contained message sent without delivery or ordering guarantees. WebTransport datagrams travel in QUIC DATAGRAM frames, are never retransmitted, and are limited in size, yet remain subject to congestion control.

Receivers may drop them, and QUIC gives them no explicit flow control. In the API, use datagrams.readable to receive and datagrams.createWritable() to send; datagrams.maxDatagramSize gives the largest allowed payload.

Sources: [RFC 9221: An Unreliable Datagram Extension to QUIC](https://www.rfc-editor.org/rfc/rfc9221.html); [draft-ietf-webtrans-overview-13: The WebTransport Protocol Framework](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-overview); [WebTransport.datagrams (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/datagrams); [WebTransportDatagramDuplexStream (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransportDatagramDuplexStream)

## Draining

A WebTransport session state entered when the server asks to gracefully wind the session down. The draining promise fulfills at that point; the session keeps working, but the application should finish up and move to a new session.

In the W3C spec, [[State]] can be connecting, connected, draining, closed or failed. At the protocol level the HTTP/3 draft signals draining with a WT_DRAIN_SESSION capsule or an HTTP/3 GOAWAY.

Sources: [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/); [WebTransport.draining (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/draining); [draft-ietf-webtrans-http3-16: WebTransport over HTTP/3](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3-16)

## Extended CONNECT

A variant of the HTTP CONNECT method that adds a :protocol pseudo-header naming the protocol to run over the stream. WebTransport sessions are created by sending an Extended CONNECT request over HTTP/3.

A server must opt in with the SETTINGS_ENABLE_CONNECT_PROTOCOL setting (identifier 0x08 in HTTP/3). The mechanism was first defined for HTTP/2 and carried over to HTTP/3.

Sources: [RFC 8441: Bootstrapping WebSockets with HTTP/2](https://www.rfc-editor.org/rfc/rfc8441.html); [RFC 9220: Bootstrapping WebSockets with HTTP/3](https://www.rfc-editor.org/rfc/rfc9220.html); [draft-ietf-webtrans-http3-16: WebTransport over HTTP/3](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3-16)

## Flow control

Limits set by a receiver to stop a sender from transmitting more data than the receiver can buffer. QUIC applies them per stream and for the whole connection, using MAX_STREAM_DATA and MAX_DATA frames.

Senders must never exceed either limit. QUIC datagrams are exempt from explicit flow control signaling.

Sources: [RFC 9000: QUIC: A UDP-Based Multiplexed and Secure Transport](https://www.rfc-editor.org/rfc/rfc9000.html); [RFC 9221: An Unreliable Datagram Extension to QUIC](https://www.rfc-editor.org/rfc/rfc9221.html)

## GOAWAY

An HTTP/3 frame that starts a graceful shutdown of a connection. After receiving it, a client cannot begin new WebTransport sessions on that connection and must open a fresh one.

The WebTransport over HTTP/3 draft also treats it as a signal that applications should wind down their sessions on that connection.

Sources: [RFC 9114: HTTP/3](https://www.rfc-editor.org/rfc/rfc9114.html); [draft-ietf-webtrans-http3-16: WebTransport over HTTP/3](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3-16)

## Head-of-line blocking

A stall in which one lost or delayed packet holds up unrelated data queued behind it. Over HTTP/2 on TCP a single loss stalls every request, whereas independent QUIC streams let other streams keep progressing.

Sources: [RFC 9114: HTTP/3](https://www.rfc-editor.org/rfc/rfc9114.html); [WebTransport API (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport_API)

## HTTP Datagrams

A convention for sending multiplexed, possibly unreliable datagrams tied to an HTTP request. Over HTTP/3 they ride in QUIC DATAGRAM frames; where those are unavailable, the DATAGRAM capsule carries them.

Each HTTP/3 datagram begins with a Quarter Stream ID, and endpoints must exchange SETTINGS_H3_DATAGRAM before sending any. The RFC says the feature is meant for HTTP extensions, not applications directly.

Sources: [RFC 9297: HTTP Datagrams and the Capsule Protocol](https://www.rfc-editor.org/rfc/rfc9297.html); [draft-ietf-webtrans-http3-16: WebTransport over HTTP/3](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3-16)

## HTTP/3

The mapping of HTTP onto QUIC instead of TCP. It relies on QUIC for stream multiplexing, per-stream flow control, loss recovery and encryption, and it is the transport that WebTransport sessions are carried over.

Clients identify it with the ALPN token "h3" or discover it through the Alt-Svc mechanism.

Sources: [RFC 9114: HTTP/3](https://www.rfc-editor.org/rfc/rfc9114.html); [draft-ietf-webtrans-http3-16: WebTransport over HTTP/3](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3-16)

## Origin header

An HTTP request header naming the web origin of the page making the request. Browsers send it when opening a WebTransport session, so servers can accept or reject connections based on which site initiated them.

The WebTransport over HTTP/3 draft says browser clients must send it and that a server whose origin check fails replies with 403.

Sources: [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/); [draft-ietf-webtrans-http3-16: WebTransport over HTTP/3](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3-16)

## QUIC

A secure, multiplexed transport protocol that runs over UDP. It offers many independent flow-controlled streams, built-in TLS 1.3 encryption and connection IDs, and it underpins both HTTP/3 and WebTransport.

QUIC packets are carried in UDP datagrams, and RFC 9002 supplies its loss detection and congestion control.

Sources: [RFC 9000: QUIC: A UDP-Based Multiplexed and Secure Transport](https://www.rfc-editor.org/rfc/rfc9000.html); [RFC 9001: Using TLS to Secure QUIC](https://www.rfc-editor.org/rfc/rfc9001.html); [RFC 9002: QUIC Loss Detection and Congestion Control](https://www.rfc-editor.org/rfc/rfc9002.html)

## ReadableStream

A Streams API object representing a source of data that you consume chunk by chunk. WebTransport exposes incoming datagrams, incoming streams and received bytes as ReadableStreams, read with getReader() or for await.

Reading a locked stream throws a TypeError, and breaking out of a for await loop cancels the stream by default. Received WebTransport data arrives as Uint8Array chunks.

Sources: [Streams Standard (WHATWG)](https://streams.spec.whatwg.org/); [ReadableStream (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream); [WebTransport.incomingUnidirectionalStreams (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/incomingUnidirectionalStreams)

## requireUnreliable

A WebTransport constructor option, false by default, that forbids falling back to a reliable-only transport such as HTTP/2. When true, the session must be established over HTTP/3, which is what makes datagrams available.

After ready, the reliability property reports "reliable-only" or "supports-unreliable", and the static WebTransport.supportsReliableOnly tells you whether the browser can fall back at all.

Sources: [WebTransport() constructor (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/WebTransport); [WebTransport.supportsReliableOnly (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/supportsReliableOnly_static); [WebTransport.reliability (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/reliability); [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/)

## Secure context

A browser environment judged sufficiently authenticated and confidential, typically an https page or localhost, in which powerful APIs are exposed. WebTransport is marked SecureContext, so it is unavailable on plain http pages.

Check window.isSecureContext, or self.isSecureContext in a worker. Dedicated workers are secure only if their owner is.

Sources: [Secure contexts (MDN)](https://developer.mozilla.org/en-US/docs/Web/Security/Defenses/Secure_Contexts); [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/); [WebTransport (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport)

## sendOrder

An integer option or property on WebTransport streams and datagram writables that sets relative send priority. Among streams that have a value, queued bytes on those with a higher value are sent first.

Without a value, ordering depends on the implementation. The W3C spec also offers sendGroup to prioritise a set of streams together.

Sources: [WebTransport.createBidirectionalStream() (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/createBidirectionalStream); [WebTransport.createUnidirectionalStream() (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/createUnidirectionalStream); [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/)

## serverCertificateHashes

A WebTransport constructor option that lets a page trust a server certificate by its SHA-256 hash instead of relying on Web PKI validation. It is meant for short-lived, self-managed certificates and works only on dedicated connections.

MDN says the certificate must be X.509v3 with under two weeks of validity and an ECDSA P-256 key, not RSA. Combining it with allowPooling: true is rejected.

Sources: [WebTransport() constructor (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/WebTransport); [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/)

## SETTINGS

An HTTP/3 frame that each endpoint sends first on its control stream, announcing connection-wide parameters as identifier and value pairs. WebTransport servers use it to announce support, including Extended CONNECT and HTTP Datagrams.

Draft 16 of the WebTransport over HTTP/3 spec names SETTINGS_WT_ENABLED, SETTINGS_ENABLE_CONNECT_PROTOCOL and SETTINGS_H3_DATAGRAM for this purpose.

Sources: [RFC 9114: HTTP/3](https://www.rfc-editor.org/rfc/rfc9114.html); [draft-ietf-webtrans-http3-16: WebTransport over HTTP/3](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3-16)

## Stream

An ordered, reliable sequence of bytes of any length inside a QUIC connection. Many streams share one connection and are delivered independently, so one stalled stream does not block the rest.

Streams are either unidirectional or bidirectional; the two low bits of a QUIC stream ID encode which type it is.

Sources: [RFC 9000: QUIC: A UDP-Based Multiplexed and Secure Transport](https://www.rfc-editor.org/rfc/rfc9000.html); [draft-ietf-webtrans-overview-13: The WebTransport Protocol Framework](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-overview)

## TLS 1.3

The current version of Transport Layer Security, providing encryption, integrity and authentication with a one-round-trip handshake. QUIC requires TLS 1.3, so WebTransport over HTTP/3 is always encrypted.

In QUIC the TLS handshake messages are carried in CRYPTO frames rather than TLS records, and endpoints must not negotiate anything older than TLS 1.3.

Sources: [RFC 8446: The Transport Layer Security (TLS) Protocol Version 1.3](https://www.rfc-editor.org/rfc/rfc8446.html); [RFC 9001: Using TLS to Secure QUIC](https://www.rfc-editor.org/rfc/rfc9001.html); [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/)

## UDP

A minimal Internet transport protocol that sends independent datagrams with no guarantee of delivery, ordering or duplicate protection. QUIC packets travel inside UDP datagrams, so networks that block UDP can break HTTP/3 and WebTransport.

Sources: [RFC 768: User Datagram Protocol](https://www.rfc-editor.org/rfc/rfc768.html); [RFC 9000: QUIC: A UDP-Based Multiplexed and Secure Transport](https://www.rfc-editor.org/rfc/rfc9000.html); [WebTransport.supportsReliableOnly (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/supportsReliableOnly_static)

## Unidirectional stream

A one-way, ordered, reliable byte stream where only the endpoint that opened it can send. In the browser, ones you open are WebTransportSendStreams and ones the server opens arrive as WebTransportReceiveStreams.

Open one with createUnidirectionalStream(); receive server-opened ones from incomingUnidirectionalStreams.

Sources: [WebTransport.createUnidirectionalStream() (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/createUnidirectionalStream); [WebTransport.incomingUnidirectionalStreams (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/incomingUnidirectionalStreams); [draft-ietf-webtrans-overview-13: The WebTransport Protocol Framework](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-overview)

## WebRTC data channel

A channel on an RTCPeerConnection for sending arbitrary data, primarily between peers. It can be configured ordered or unordered and with limited retransmits, whereas WebTransport connects a client to a server over HTTP/3.

MDN describes it as carried over SCTP and DTLS, and notes the theoretical limit of 65,534 channels per peer connection.

Sources: [RTCDataChannel (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel); [WebTransport (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport)

## WebSocket

A TCP-based protocol that starts with an HTTP Upgrade handshake and then exchanges framed text or binary messages over one connection. Unlike WebTransport it has no independent streams or datagrams, and its browser API has no backpressure.

It uses ws and wss URL schemes, and browsers send an Origin header so servers can reject unwanted origins.

Sources: [RFC 6455: The WebSocket Protocol](https://www.rfc-editor.org/rfc/rfc6455.html); [WebSocket (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket)

## WebTransport

A web API and protocol framework for client-server communication over HTTP/3, giving one connection many independent reliable streams plus unreliable datagrams. It is a more flexible alternative to WebSocket for latency-sensitive apps.

The browser API is a W3C specification; the wire protocol is defined by IETF drafts that are still in progress.

Sources: [WebTransport (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport); [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/); [draft-ietf-webtrans-overview-13: The WebTransport Protocol Framework](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-overview); [draft-ietf-webtrans-http3-16: WebTransport over HTTP/3](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3-16)

## WebTransport session

A single communication context between a WebTransport client and server. It groups the streams and datagrams exchanged between them and is created by an HTTP/3 request, and it ends when closed.

A session may own a dedicated connection or share one with other sessions when pooling is allowed; sessions on a shared connection are logically independent.

Sources: [draft-ietf-webtrans-overview-13: The WebTransport Protocol Framework](https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-overview); [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/); [WebTransport() constructor (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransport/WebTransport)

## WebTransportError

The error type produced by WebTransport operations. It extends DOMException and adds a source, either "stream" or "session", plus an optional streamErrorCode that the application can set when aborting a stream.

Constructing a bad URL throws a plain SyntaxError instead, so check instanceof WebTransportError before reading these fields.

Sources: [WebTransportError (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WebTransportError); [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/)

## WritableStream

A Streams API object representing a destination you write chunks to, with built-in queuing and backpressure. WebTransport uses WritableStreams for outgoing bytes and datagrams, written through getWriter().

Calling abort() puts the stream in an error state and discards queued writes. On a WebTransport send stream, abort can carry an application error code.

Sources: [Streams Standard (WHATWG)](https://streams.spec.whatwg.org/); [WritableStream (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/WritableStream); [WebTransport (W3C Working Draft)](https://www.w3.org/TR/webtransport/)