How to test WebTransport locally with an example server

What do I need to test WebTransport locally?

You need three things: a server that speaks WebTransport over HTTP/3, a certificate the browser will accept, and a client. The easiest path is to let a library’s example generate a self-signed certificate and serve its own test page. The commands below come from each project’s README and example source as of 2026-10-28. Treat them as examples and check the repository for current instructions.

Text version

1. The browser sends "hello" to the server on a stream (blue) or as a datagram (amber).
2. The echo server sends the same bytes back (teal-green).
3. The browser shows the echo. If it arrives, DNS, UDP, QUIC, HTTP/3, the certificate and the origin check all worked.

Option 1: Rust, the wtransport “full” example

The wtransport repository includes client.rs, server.rs, full.rs and gencert.rs in its examples. From a clone of the repository:

cargo run --example full

According to the example’s source, it:

• starts an HTTP server on 127.0.0.1:8080 serving a test page, and a WebTransport server on an operating-system-assigned UDP port,
• creates a self-signed identity for localhost, 127.0.0.1 and ::1, and
• injects the SHA-256 hash of that certificate into the page, which passes it as serverCertificateHashes.

Open http://127.0.0.1:8080, press connect, and send something. The server acknowledges each stream and datagram with the text ACK; it does not echo your bytes back.

Option 2: Go, the webtransport-go example

The webtransport-go README says it implements draft-16, and its example directory has a server, a Go client and a browser client:

cd example/server
go run .

Per the example README, the server prints the certificate hash, serves a browser client at http://localhost:6120, and runs WebTransport at https://localhost:6121/webtransport. The certificate is a deterministically generated P-256 certificate that rotates weekly. Open the browser client with the hash pre-filled and press connect. The README does not say whether this server echoes data, so check its source if you need that.

Option 3: a true echo server

For a server that returns your bytes, use the W3C WebTransport samples echo server (source), or the Python aioquic examples, where demo.py echoes datagrams and stream data at /wt. The aioquic examples README gives the server command:

python examples/http3_server.py --certificate cert.pem --private-key key.pem

Their echo endpoint is then https://localhost:4433/wt. That README accepts an older draft than current browsers may expect and mentions Chrome flags for self-signed certificates; we could not confirm interoperability with current browsers, so verify before relying on it.

How do I use my own certificate?

Generate an ECDSA P-256 certificate valid for less than two weeks and hash it, as described in debugging handshake errors:

openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -nodes \
  -days 13 -subj "/CN=localhost" -addext "subjectAltName=DNS:localhost" \
  -keyout key.pem -out cert.pem

openssl x509 -in cert.pem -outform der | openssl dgst -sha256

Start your server with cert.pem and key.pem, then paste the hash into the self-signed certificate field in the WebTransport tester and connect to https://localhost:<port>/<path>.

How do I test my own client code?

Use the example server for the transport and write your client against it. A minimal browser client looks like this (an example, with a placeholder URL and hash handling left to you):

const hash = Uint8Array.from(/* 32 bytes of your certificate's SHA-256 */);
const transport = new WebTransport('https://localhost:4433/echo', {
  serverCertificateHashes: [{ algorithm: 'sha-256', value: hash }],
});
await transport.ready;
console.log('connected');
transport.close();

If the connection fails, work through the handshake checklist. For library choices, see WebTransport libraries.