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 ascurl --http3-only.

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.

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:
# 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 aquinn::Endpoint(re-exported asakev_proxy::quinn; build one over any socket withEndpoint::new_with_abstract_socket). With an original destination, requests go there (the:authorityonly 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, ALPNh3).ProxyHandle::http3_status()— the built-in listener's state (Status.proxy.http3in 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 finalh3version is spoken (not drafts such ash3-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-Svcknowledge lives in memory: it starts empty at each launch (persistis ignored).- Byte counters (
Status.stats) include HTTP/3 connections once they close.