DocsHTTP/3

Inspect

HTTP/3

Akev speaks HTTP/3 (HTTP over QUIC, RFC 9114) on both sides of the proxy:

  • To servers — requests to HTTPS servers can go upstream over QUIC: for servers that advertise HTTP/3, for every HTTPS server, or for a single Compose request.
  • From clients — an optional QUIC listener accepts HTTP/3 from clients sent to Akev directly, and records their requests as HTTP/3 exchanges that go through your rules, breakpoints and the rest of the pipeline like any other.

Everything is off by default. Turn it on in Settings → Proxy → HTTP/3 (changes apply immediately, no restart).

What it doesn't do. Browsers and apps that use Akev as their proxy reach it over TCP (CONNECT), so their side of the connection is always HTTP/1.1 or HTTP/2: an HTTP proxy can't carry QUIC, which runs over UDP. WireGuard mode drops QUIC on purpose so apps fall back to TCP. HTTP/3 shows up on the client side only for clients you point at the QUIC listener directly, such as curl --http3-only.

Settings → Proxy → HTTP/3
Settings → Proxy → HTTP/3

HTTP/3 to servers

HTTP/3 to servers decides when Akev uses QUIC for requests it forwards:

Mode What happens
Off (default) HTTP/1.1 or HTTP/2 over TCP, as before.
Alt-Svc Like browsers: once a server answers with an Alt-Svc: h3=":443" header, its next requests go over HTTP/3 for as long as the header's ma (max-age, 24 h by default) says. Alt-Svc: clear withdraws it. Alternatives on another port or host are followed; the certificate is still checked for the original host.
Prefer Every HTTPS server is tried over HTTP/3 first.

Whatever the mode, a server that doesn't answer over QUIC (no HTTP/3 support, UDP blocked by a firewall, handshake or certificate failure) gets the request over TCP instead, with nothing lost: the request body is only sent once the QUIC connection is up. The server is then left alone for 5 minutes (doubling after each new failure, up to an hour), so a network that blocks UDP costs one slow attempt per server, not one per request. Automatic attempts give the handshake at most 2 seconds (or the connect timeout, if shorter).

HTTP/3 uses the same certificate rules as TCP: your trusted CA certificates, ignore certificate errors hosts and client certificates apply, and the server's certificate shows in the exchange's Connection tab.

Where HTTP/3 is never used: http:// URLs, WebSocket upgrades (they need HTTP/1.1), requests that asked for HTTP/1.1, and everything sent through an upstream proxy (QUIC can't be tunnelled through an HTTP proxy).

In an exchange, the Connection tab shows both sides — e.g. HTTP version: HTTP/2 → HTTP/3 for a browser talking HTTP/2 to Akev while Akev talks HTTP/3 to the server — and the upstream ALPN h3.

HTTP/2 from the client, HTTP/3 to the server
HTTP/2 from the client, HTTP/3 to the server

Compose

The request options (the sliders button next to Send) have an HTTP version choice:

  • Auto — the settings decide (HTTP/2 when the server offers it, HTTP/3 per the mode above).
  • HTTP/1.1 — never HTTP/2 or HTTP/3.
  • HTTP/2 — over TCP (HTTP/2 when the server offers it, otherwise HTTP/1.1), never HTTP/3.
  • HTTP/3 — over QUIC first, whatever the settings say; falls back to TCP when the server doesn't answer over QUIC (like curl --http3).

The response shows the version actually used, and so does the recorded exchange. Through the API it's options.httpVersion on POST /api/send and POST /api/exchanges/:id/replay, and httpVersion on the MCP tools akev_send_request / akev_replay.

HTTP/3 from clients

Accept HTTP/3 from clients opens a QUIC (UDP) listener on the proxy's port number (or the QUIC port you set) and bind address. It presents Akev's certificates — one per server name, signed by the Akev CA, exactly as for intercepted HTTPS — so clients must trust the Akev CA.

This is for clients sent to Akev directly, the way a reverse proxy or a transparent setup receives traffic: the request's :authority names the server Akev forwards to. For example:

bash
# Ask Akev for https://example.com over HTTP/3
curl --http3-only --cacert "$(akev ca path)" \
     --connect-to example.com:443:127.0.0.1:8000 https://example.com/

DNS overrides or hosts-file entries pointing a name at the machine running Akev work the same way (with the QUIC port set to 443, which may need administrator rights).

Requests arrive in Traffic as HTTP/3 (h3 in the protocol column), with the client's SNI and ALPN in the Connection tab. Requests addressed to Akev itself (or akev.cert) get the setup page, as over TCP. Clients that reject Akev's certificate show up as TLS failures when Record TLS failures is on.

Browsers using Akev as their proxy don't use this listener. A browser configured with an HTTP proxy talks HTTP/1.1 or HTTP/2 to the proxy (CONNECT tunnels) and doesn't send QUIC through it; Akev can still use HTTP/3 for the upstream side (above). Browsers also decide on their own when to use QUIC — Chromium-based ones, for instance, only switch an origin to HTTP/3 after seeing it advertised, and --origin-to-force-quic-on=host:port forces it for testing.

For integrators

akev-proxy exposes the building blocks to serve HTTP/3 on any QUIC endpoint — e.g. one fed by a userspace network stack (VPN / WireGuard / transparent capture) handing over UDP/443 flows:

  • ProxyHandle::serve_quic(endpoint, original_destination) — accept HTTP/3 connections from a quinn::Endpoint (re-exported as akev_proxy::quinn; build one over any socket with Endpoint::new_with_abstract_socket). With an original destination, requests go there (the :authority only names the host), like a CONNECT tunnel to an IP.
  • ProxyHandle::serve_quic_socket(udp_socket, original_destination) — the same on a bound UDP socket.
  • ProxyHandle::quic_server_config(local_ip) — the QUIC server configuration (Akev leaf certificates per SNI, TLS 1.3, ALPN h3).
  • ProxyHandle::http3_status() — the built-in listener's state (Status.proxy.http3 in the API).

Platforms

Pure Rust (quinn + h3, rustls with the ring provider): Linux, macOS and Windows, no root or system configuration needed (the listener only binds a UDP port). Verified on Linux against public HTTP/3 servers (Cloudflare, Google) and with curl --http3-only.

Limitations

  • No 0-RTT (early data) on either side, no server push, no CONNECT / extended CONNECT (WebSockets over HTTP/3, WebTransport, MASQUE) on the listener — WebSockets stay on HTTP/1.1. Only the final h3 version is spoken (not drafts such as h3-29).
  • QUIC doesn't expose everything TCP+TLS does: no JA3/JA4 fingerprint or cipher suite for HTTP/3 clients, no upstream cipher suite, and the process that owns a QUIC connection isn't detected (the Source column stays empty for HTTP/3 clients).
  • Timings: the QUIC handshake (transport and TLS in one round trip) is reported as Connect; there is no separate TLS phase.
  • A client that cancels a single HTTP/3 request is noticed when Akev next writes to that stream (a closed connection is noticed at once); an upstream request already sent keeps running until then.
  • With Prefer, the first request to an HTTPS server without HTTP/3 waits up to 2 seconds before falling back to TCP (then the server is remembered). Alt-Svc avoids this.
  • Alt-Svc knowledge lives in memory: it starts empty at each launch (persist is ignored).
  • Byte counters (Status.stats) include HTTP/3 connections once they close.

Type to search guides, the CLI and the API.