QUIC

Stability: 1.0 - Early development

The 'node:quic' module provides an implementation of the QUIC protocol. To access it, start Node.js with the --experimental-quic option and:

import quic from 'node:quic';

const quic = require('node:quic');

The module is only available under the node: scheme.

quic.connect(address[, options])

• address {string|net.SocketAddress}
• options {quic.SessionOptions}
• Returns: {Promise} a promise for a {quic.QuicSession}

Initiate a new client-side session.

import { connect } from 'node:quic';
import { Buffer } from 'node:buffer';

const enc = new TextEncoder();
const alpn = 'foo';
const client = await connect('123.123.123.123:8888', { alpn });
await client.createUnidirectionalStream({
  body: enc.encode('hello world'),
});

By default, every call to connect(...) will create a new local QuicEndpoint instance bound to a new random local IP port. To specify the exact local address to use, or to multiplex multiple QUIC sessions over a single local port, pass the endpoint option with either a QuicEndpoint or EndpointOptions as the argument.

import { QuicEndpoint, connect } from 'node:quic';

const endpoint = new QuicEndpoint({
  address: '127.0.0.1:1234',
});

const client = await connect('123.123.123.123:8888', { endpoint });

quic.listen(onsession,[options])

• onsession {quic.OnSessionCallback}
• options {quic.SessionOptions}
• Returns: {Promise} a promise for a {quic.QuicEndpoint}

Configures the endpoint to listen as a server. When a new session is initiated by a remote peer, the given onsession callback will be invoked with the created session.

import { listen } from 'node:quic';

const endpoint = await listen((session) => {
  // ... handle the session
});

// Closing the endpoint allows any sessions open when close is called
// to complete naturally while preventing new sessions from being
// initiated. Once all existing sessions have finished, the endpoint
// will be destroyed. The call returns a promise that is resolved once
// the endpoint is destroyed.
await endpoint.close();

By default, every call to listen(...) will create a new local QuicEndpoint instance bound to a new random local IP port. To specify the exact local address to use, or to multiplex multiple QUIC sessions over a single local port, pass the endpoint option with either a QuicEndpoint or EndpointOptions as the argument.

At most, any single QuicEndpoint can only be configured to listen as a server once.

Class: QuicEndpoint

A QuicEndpoint encapsulates the local UDP-port binding for QUIC. It can be used as both a client and a server.

new QuicEndpoint([options])

• options {quic.EndpointOptions}

endpoint.address

• Type: {net.SocketAddress|undefined}

The local UDP socket address to which the endpoint is bound, if any.

If the endpoint is not currently bound then the value will be undefined. Read only.

endpoint.busy

• Type: {boolean}

When endpoint.busy is set to true, the endpoint will temporarily reject new sessions from being created. Read/write.

// Mark the endpoint busy. New sessions will be prevented.
endpoint.busy = true;

// Mark the endpoint free. New session will be allowed.
endpoint.busy = false;

The busy property is useful when the endpoint is under heavy load and needs to temporarily reject new sessions while it catches up.

endpoint.close()

• Returns: {Promise}

Gracefully close the endpoint. The endpoint will close and destroy itself when all currently open sessions close. Once called, new sessions will be rejected.

Returns a promise that is fulfilled when the endpoint is destroyed.

endpoint.closed

• Type: {Promise}

A promise that is fulfilled when the endpoint is destroyed. This will be the same promise that is returned by the endpoint.close() function. Read only.

endpoint.closing

• Type: {boolean}

True if endpoint.close() has been called and closing the endpoint has not yet completed. Read only.

endpoint.destroy([error])

• error {any}

Forcefully closes the endpoint by forcing all open sessions to be immediately closed.

endpoint.destroyed

• Type: {boolean}

True if endpoint.destroy() has been called. Read only.

endpoint.stats

• Type: {quic.QuicEndpoint.Stats}

The statistics collected for an active session. Read only.

endpoint[Symbol.asyncDispose]()

Calls endpoint.close() and returns a promise that fulfills when the endpoint has closed.

Class: QuicEndpoint.Stats

A view of the collected statistics for an endpoint.

endpointStats.createdAt

• Type: {bigint} A timestamp indicating the moment the endpoint was created. Read only.

endpointStats.destroyedAt

• Type: {bigint} A timestamp indicating the moment the endpoint was destroyed. Read only.

endpointStats.bytesReceived

• Type: {bigint} The total number of bytes received by this endpoint. Read only.

endpointStats.bytesSent

• Type: {bigint} The total number of bytes sent by this endpoint. Read only.

endpointStats.packetsReceived

• Type: {bigint} The total number of QUIC packets successfully received by this endpoint. Read only.

endpointStats.packetsSent

• Type: {bigint} The total number of QUIC packets successfully sent by this endpoint. Read only.

endpointStats.serverSessions

• Type: {bigint} The total number of peer-initiated sessions received by this endpoint. Read only.

endpointStats.clientSessions

• Type: {bigint} The total number of sessions initiated by this endpoint. Read only.

endpointStats.serverBusyCount

• Type: {bigint} The total number of times an initial packet was rejected due to the endpoint being marked busy. Read only.

endpointStats.retryCount

• Type: {bigint} The total number of QUIC retry attempts on this endpoint. Read only.

endpointStats.versionNegotiationCount

• Type: {bigint} The total number sessions rejected due to QUIC version mismatch. Read only.

endpointStats.statelessResetCount

• Type: {bigint} The total number of stateless resets handled by this endpoint. Read only.

endpointStats.immediateCloseCount

• Type: {bigint} The total number of sessions that were closed before handshake completed. Read only.

Class: QuicSession

A QuicSession represents the local side of a QUIC connection.

session.close()

• Returns: {Promise}

Initiate a graceful close of the session. Existing streams will be allowed to complete but no new streams will be opened. Once all streams have closed, the session will be destroyed. The returned promise will be fulfilled once the session has been destroyed.

session.closed

• Type: {Promise}

A promise that is fulfilled once the session is destroyed.

session.destroy([error])

• error {any}

Immediately destroy the session. All streams will be destroys and the session will be closed.

session.destroyed

• Type: {boolean}

True if session.destroy() has been called. Read only.

session.endpoint

• Type: {quic.QuicEndpoint}

The endpoint that created this session. Read only.

session.onstream

• Type: {quic.OnStreamCallback}

The callback to invoke when a new stream is initiated by a remote peer. Read/write.

session.ondatagram

• Type: {quic.OnDatagramCallback}

The callback to invoke when a new datagram is received from a remote peer. Read/write.

session.ondatagramstatus

• Type: {quic.OnDatagramStatusCallback}

The callback to invoke when the status of a datagram is updated. Read/write.

session.onpathvalidation

• Type: {quic.OnPathValidationCallback}

The callback to invoke when the path validation is updated. Read/write.

session.onsessionticket

• Type: {quic.OnSessionTicketCallback}

The callback to invoke when a new session ticket is received. Read/write.

session.onversionnegotiation

• Type: {quic.OnVersionNegotiationCallback}

The callback to invoke when a version negotiation is initiated. Read/write.

session.onhandshake

• Type: {quic.OnHandshakeCallback}

The callback to invoke when the TLS handshake is completed. Read/write.

session.createBidirectionalStream([options])

• options {Object}
  • body {ArrayBuffer | ArrayBufferView | Blob}
  • sendOrder {number}
• Returns: {Promise} for a {quic.QuicStream}

Open a new bidirectional stream. If the body option is not specified, the outgoing stream will be half-closed.

session.createUnidirectionalStream([options])

• options {Object}
  • body {ArrayBuffer | ArrayBufferView | Blob}
  • sendOrder {number}
• Returns: {Promise} for a {quic.QuicStream}

Open a new unidirectional stream. If the body option is not specified, the outgoing stream will be closed.

session.path

• Type: {Object|undefined}
  • local {net.SocketAddress}
  • remote {net.SocketAddress}

The local and remote socket addresses associated with the session. Read only.

session.sendDatagram(datagram)

• datagram {string|ArrayBufferView}
• Returns: {bigint}

Sends an unreliable datagram to the remote peer, returning the datagram ID. If the datagram payload is specified as an ArrayBufferView, then ownership of that view will be transferred to the underlying stream.

session.stats

• Type: {quic.QuicSession.Stats}

Return the current statistics for the session. Read only.

session.updateKey()

Initiate a key update for the session.

session[Symbol.asyncDispose]()

Calls session.close() and returns a promise that fulfills when the session has closed.

Class: QuicSession.Stats

sessionStats.createdAt

• Type: {bigint}

sessionStats.closingAt

• Type: {bigint}

sessionStats.handshakeCompletedAt

• Type: {bigint}

sessionStats.handshakeConfirmedAt

• Type: {bigint}

sessionStats.bytesReceived

• Type: {bigint}

sessionStats.bytesSent

• Type: {bigint}

sessionStats.bidiInStreamCount

• Type: {bigint}

sessionStats.bidiOutStreamCount

• Type: {bigint}

sessionStats.uniInStreamCount

• Type: {bigint}

sessionStats.uniOutStreamCount

• Type: {bigint}

sessionStats.maxBytesInFlights

• Type: {bigint}

sessionStats.bytesInFlight

• Type: {bigint}

sessionStats.blockCount

• Type: {bigint}

sessionStats.cwnd

• Type: {bigint}

sessionStats.latestRtt

• Type: {bigint}

sessionStats.minRtt

• Type: {bigint}

sessionStats.rttVar

• Type: {bigint}

sessionStats.smoothedRtt

• Type: {bigint}

sessionStats.ssthresh

• Type: {bigint}

sessionStats.datagramsReceived

• Type: {bigint}

sessionStats.datagramsSent

• Type: {bigint}

sessionStats.datagramsAcknowledged

• Type: {bigint}

sessionStats.datagramsLost

• Type: {bigint}

Class: QuicStream

stream.closed

• Type: {Promise}

A promise that is fulfilled when the stream is fully closed.

stream.destroy([error])

• error {any}

Immediately and abruptly destroys the stream.

stream.destroyed

• Type: {boolean}

True if stream.destroy() has been called.

stream.direction

• Type: {string} One of either 'bidi' or 'uni'.

The directionality of the stream. Read only.

stream.id

• Type: {bigint}

The stream ID. Read only.

stream.onblocked

• Type: {quic.OnBlockedCallback}

The callback to invoke when the stream is blocked. Read/write.

stream.onreset

• Type: {quic.OnStreamErrorCallback}

The callback to invoke when the stream is reset. Read/write.

stream.readable

• Type: {ReadableStream}

stream.session

• Type: {quic.QuicSession}

The session that created this stream. Read only.

stream.stats

• Type: {quic.QuicStream.Stats}

The current statistics for the stream. Read only.

Class: QuicStream.Stats

streamStats.ackedAt

• Type: {bigint}

streamStats.bytesReceived

• Type: {bigint}

streamStats.bytesSent

• Type: {bigint}

streamStats.createdAt

• Type: {bigint}

streamStats.destroyedAt

• Type: {bigint}

streamStats.finalSize

• Type: {bigint}

streamStats.isConnected

• Type: {bigint}

streamStats.maxOffset

• Type: {bigint}

streamStats.maxOffsetAcknowledged

• Type: {bigint}

streamStats.maxOffsetReceived

• Type: {bigint}

streamStats.openedAt

• Type: {bigint}

streamStats.receivedAt

• Type: {bigint}

Types

Type: EndpointOptions

• Type: {Object}

The endpoint configuration options passed when constructing a new QuicEndpoint instance.

endpointOptions.address

• Type: {net.SocketAddress | string} The local UDP address and port the endpoint should bind to.

If not specified the endpoint will bind to IPv4 localhost on a random port.

endpointOptions.addressLRUSize

• Type: {bigint|number}

The endpoint maintains an internal cache of validated socket addresses as a performance optimization. This option sets the maximum number of addresses that are cache. This is an advanced option that users typically won't have need to specify.

endpointOptions.ipv6Only

• Type: {boolean}

When true, indicates that the endpoint should bind only to IPv6 addresses.

endpointOptions.maxConnectionsPerHost

• Type: {bigint|number}

Specifies the maximum number of concurrent sessions allowed per remote peer address.

endpointOptions.maxConnectionsTotal

• Type: {bigint|number}

Specifies the maximum total number of concurrent sessions.

endpointOptions.maxRetries

• Type: {bigint|number}

Specifies the maximum number of QUIC retry attempts allowed per remote peer address.

endpointOptions.maxStatelessResetsPerHost

• Type: {bigint|number}

Specifies the maximum number of stateless resets that are allowed per remote peer address.

endpointOptions.retryTokenExpiration

• Type: {bigint|number}

Specifies the length of time a QUIC retry token is considered valid.

endpointOptions.resetTokenSecret

• Type: {ArrayBufferView}

Specifies the 16-byte secret used to generate QUIC retry tokens.

endpointOptions.tokenExpiration

• Type: {bigint|number}

Specifies the length of time a QUIC token is considered valid.

endpointOptions.tokenSecret

• Type: {ArrayBufferView}

Specifies the 16-byte secret used to generate QUIC tokens.

endpointOptions.udpReceiveBufferSize

• Type: {number}

endpointOptions.udpSendBufferSize

• Type: {number}

endpointOptions.udpTTL

• Type: {number}

endpointOptions.validateAddress

• Type: {boolean}

When true, requires that the endpoint validate peer addresses using retry packets while establishing a new connection.

Type: SessionOptions

sessionOptions.alpn

• Type: {string}

The ALPN protocol identifier.

sessionOptions.ca

• Type: {ArrayBuffer|ArrayBufferView|ArrayBuffer[]|ArrayBufferView[]}

The CA certificates to use for sessions.

sessionOptions.cc

• Type: {string}

Specifies the congestion control algorithm that will be used . Must be set to one of either 'reno', 'cubic', or 'bbr'.

This is an advanced option that users typically won't have need to specify.

sessionOptions.certs

• Type: {ArrayBuffer|ArrayBufferView|ArrayBuffer[]|ArrayBufferView[]}

The TLS certificates to use for sessions.

sessionOptions.ciphers

• Type: {string}

The list of supported TLS 1.3 cipher algorithms.

sessionOptions.crl

• Type: {ArrayBuffer|ArrayBufferView|ArrayBuffer[]|ArrayBufferView[]}

The CRL to use for sessions.

sessionOptions.groups

• Type: {string}

The list of support TLS 1.3 cipher groups.

sessionOptions.keylog

• Type: {boolean}

True to enable TLS keylogging output.

sessionOptions.keys

• Type: {KeyObject|KeyObject[]}

The TLS crypto keys to use for sessions.

sessionOptions.maxPayloadSize

• Type: {bigint|number}

Specifies the maximum UDP packet payload size.

sessionOptions.maxStreamWindow

• Type: {bigint|number}

Specifies the maximum stream flow-control window size.

sessionOptions.maxWindow

• Type: {bigint|number}

Specifies the maximum session flow-control window size.

sessionOptions.minVersion

• Type: {number}

The minimum QUIC version number to allow. This is an advanced option that users typically won't have need to specify.

sessionOptions.preferredAddressPolicy

• Type: {string} One of 'use', 'ignore', or 'default'.

When the remote peer advertises a preferred address, this option specifies whether to use it or ignore it.

sessionOptions.qlog

• Type: {boolean}

True if qlog output should be enabled.

sessionOptions.sessionTicket

• Type: {ArrayBufferView} A session ticket to use for 0RTT session resumption.

sessionOptions.handshakeTimeout

• Type: {bigint|number}

Specifies the maximum number of milliseconds a TLS handshake is permitted to take to complete before timing out.

sessionOptions.sni

• Type: {string}

The peer server name to target.

sessionOptions.tlsTrace

• Type: {boolean}

True to enable TLS tracing output.

sessionOptions.transportParams

• Type: {quic.TransportParams}

The QUIC transport parameters to use for the session.

sessionOptions.unacknowledgedPacketThreshold

• Type: {bigint|number}

Specifies the maximum number of unacknowledged packets a session should allow.

sessionOptions.verifyClient

• Type: {boolean}

True to require verification of TLS client certificate.

sessionOptions.verifyPrivateKey

• Type: {boolean}

True to require private key verification.

sessionOptions.version

• Type: {number}

The QUIC version number to use. This is an advanced option that users typically won't have need to specify.

Type: TransportParams

transportParams.preferredAddressIpv4

• Type: {net.SocketAddress} The preferred IPv4 address to advertise.

transportParams.preferredAddressIpv6

• Type: {net.SocketAddress} The preferred IPv6 address to advertise.

transportParams.initialMaxStreamDataBidiLocal

• Type: {bigint|number}

transportParams.initialMaxStreamDataBidiRemote

• Type: {bigint|number}

transportParams.initialMaxStreamDataUni

• Type: {bigint|number}

transportParams.initialMaxData

• Type: {bigint|number}

transportParams.initialMaxStreamsBidi

• Type: {bigint|number}

transportParams.initialMaxStreamsUni

• Type: {bigint|number}

transportParams.maxIdleTimeout

• Type: {bigint|number}

transportParams.activeConnectionIDLimit

• Type: {bigint|number}

transportParams.ackDelayExponent

• Type: {bigint|number}

transportParams.maxAckDelay

• Type: {bigint|number}

transportParams.maxDatagramFrameSize

• Type: {bigint|number}

Callbacks

Callback: OnSessionCallback

• this {quic.QuicEndpoint}
• session {quic.QuicSession}

The callback function that is invoked when a new session is initiated by a remote peer.

Callback: OnStreamCallback

• this {quic.QuicSession}
• stream {quic.QuicStream}

Callback: OnDatagramCallback

• this {quic.QuicSession}
• datagram {Uint8Array}
• early {boolean}

Callback: OnDatagramStatusCallback

• this {quic.QuicSession}
• id {bigint}
• status {string} One of either 'lost' or 'acknowledged'.

Callback: OnPathValidationCallback

• this {quic.QuicSession}
• result {string} One of either 'success', 'failure', or 'aborted'.
• newLocalAddress {net.SocketAddress}
• newRemoteAddress {net.SocketAddress}
• oldLocalAddress {net.SocketAddress}
• oldRemoteAddress {net.SocketAddress}
• preferredAddress {boolean}

Callback: OnSessionTicketCallback

• this {quic.QuicSession}
• ticket {Object}

Callback: OnVersionNegotiationCallback

• this {quic.QuicSession}
• version {number}
• requestedVersions {number[]}
• supportedVersions {number[]}

Callback: OnHandshakeCallback

• this {quic.QuicSession}
• sni {string}
• alpn {string}
• cipher {string}
• cipherVersion {string}
• validationErrorReason {string}
• validationErrorCode {number}
• earlyDataAccepted {boolean}

Callback: OnBlockedCallback

• this {quic.QuicStream}

Callback: OnStreamErrorCallback

• this {quic.QuicStream}
• error {any}

Diagnostic Channels

Channel: quic.endpoint.created

• endpoint {quic.QuicEndpoint}
• config {quic.EndpointOptions}

Channel: quic.endpoint.listen

• endpoint {quic.QuicEndpoint}
• optoins {quic.SessionOptions}

Channel: quic.endpoint.closing

• endpoint {quic.QuicEndpoint}
• hasPendingError {boolean}

Channel: quic.endpoint.closed

• endpoint {quic.QuicEndpoint}

Channel: quic.endpoint.error

• endpoint {quic.QuicEndpoint}
• error {any}

Channel: quic.endpoint.busy.change

• endpoint {quic.QuicEndpoint}
• busy {boolean}

Channel: quic.session.created.client

Channel: quic.session.created.server

Channel: quic.session.open.stream

Channel: quic.session.received.stream

Channel: quic.session.send.datagram

Channel: quic.session.update.key

Channel: quic.session.closing

Channel: quic.session.closed

Channel: quic.session.receive.datagram

Channel: quic.session.receive.datagram.status

Channel: quic.session.path.validation

Channel: quic.session.ticket

Channel: quic.session.version.negotiation

Channel: quic.session.handshake