A bot check does not need JavaScript to spot most scripted clients. The first message of every HTTPS connection, the TLS ClientHello, is sent before the request line and says a lot about the software that built it. Since 2024, Chrome's version of that message carries something many HTTP libraries did not have for a long time: a post-quantum key share.
What Chrome sends now
TLS 1.3 lets a client guess the key exchange the server will pick and send its half of the key in the first message, so the handshake needs one round trip instead of two. Chrome now guesses a hybrid of classic X25519 and a post-quantum scheme, and it got there in three steps:
| When | What changed | Source |
|---|---|---|
| Aug 2023 | Chrome announces hybrid Kyber key agreement, X25519Kyber768, starting as an option. | Chromium blog |
| Apr 2024 | Version 124 turns it on by default on desktop (codepoint 0x6399). | Intent to ship |
| Nov 2024 | Version 131 drops Kyber and offers the standard ML-KEM hybrid, X25519MLKEM768, codepoint 0x11EC. | Google Security blog |
The IETF draft that defines the hybrid puts the client share at 1,216 bytes: 1,184 for ML-KEM-768 and 32 for X25519. A classic X25519 share is 32 bytes. That one field pushes the ClientHello past what fits in a single packet, which is why some servers broke when Chrome turned it on: they expected the whole hello in one read(). The tldr.fail page documents that bug.
Same User-Agent, different handshake
A scraper that sends a Chrome User-Agent from Python, Go or curl changes one HTTP header. The TLS library underneath still writes its own ClientHello: its own cipher list, its own extensions, its own key share. The server sees the handshake first and the header second.
We pointed six clients at tls.peet.ws, which echoes back the ClientHello it received, on 17 November 2026:
| Client | Key share | JA4 |
|---|---|---|
| Google Chrome, current stable, macOS | X25519MLKEM768, X25519 | t13d1517h2_8daaf6152771_cb7bf5808d99 |
| Phantom, Browsa production | X25519MLKEM768, X25519 | t13d1517h2_8daaf6152771_cb7bf5808d99 |
| curl 8.7.1, macOS system build (LibreSSL) | X25519 only | t13d497h2_0d8feac7bc37_7395dae3b2f3 |
| Python requests 2.32, OpenSSL 3.6 | X25519MLKEM768, X25519 | t13d1712h1_ab0a1bf427ad_882d495ac381 |
Go 1.26 net/http | X25519MLKEM768, X25519 | t13d1312h2_f57a46bbacb6_ab7e3b40a677 |
Node 26 fetch | X25519MLKEM768, X25519 | t13d5212h1_b262b3658495_8e6e362c5eac |
Two things stand out. First, the missing key share is now a sign of an old stack, not of every library. OpenSSL added X25519MLKEM768 to its default key shares in 3.5.0 (April 2025). Go offered the Kyber draft by default in 1.23 and switched to ML-KEM in 1.24. Python linked against OpenSSL 3.4 or older, Go before 1.23, and curl builds like the macOS one above still send a classic share only. Go 1.23 sends the 0x6399 draft that Chrome stopped offering in 2024, which is a mismatch of its own.
Second, a matching key share is not a matching handshake. Python, Go and Node all offer ML-KEM now, and none of them looks like Chrome: different cipher counts, different extensions. Python requests offers only HTTP/1.1, and Node lists HTTP/1.1 before HTTP/2. Chrome and Phantom produce the same JA4.
JA4 in one minute
JA4, from FoxIO, turns a ClientHello into a short string with three parts. Take Chrome's:
t13d1517h2: TLS over TCP, version 1.3, a domain name in SNI, 15 cipher suites, 17 extensions, andh2as the first ALPN value.8daaf6152771: a truncated SHA-256 of the cipher suites, sorted.cb7bf5808d99: a truncated SHA-256 of the extensions, sorted, plus the signature algorithms in their sent order.
JA4 ignores GREASE values and sorts the lists, so a client that shuffles its extension order still gets one stable value. It does not hash the key share bytes, but the extension list and counts move whenever a library's defaults move, and a Chrome User-Agent next to a JA4 that no Chrome release sends is a contradiction a server can check before it serves a byte.
The handshake also changes between Chrome releases. A TLS profile copied from mid-2024 Chrome offers the 0x6399 Kyber share, which Chrome stopped sending in version 131. A frozen copy of Chrome becomes a fingerprint of its own.
Check your own client
Run these from the same machine, library and proxy your agent uses. Replace curl with your client.
# JA4 of the ClientHello your client sent
curl -s https://tls.peet.ws/api/all | python3 -c "import sys, json; print(json.load(sys.stdin)['tls']['ja4'])"
# The key exchange Cloudflare negotiated with you
curl -s https://www.cloudflare.com/cdn-cgi/trace | grep kexChrome and Phantom print kex=X25519MLKEM768 on the second line. The macOS system curl prints kex=X25519.
To check a whole browser rather than one HTTP client, open browsa.io/detect in your agent's browser. It checks TLS, HTTP/2 and the IP address along with what page scripts can see.
What to do about it
- Use a real browser engine. A browser sends its own handshake, so there is nothing to keep in sync. Phantom, Browsa's own browser, uses the same TLS code as Chrome: in the capture above its JA4 matched Chrome's exactly, and so did its HTTP/2 settings fingerprint.
- Or use a library that copies the current Chrome. Projects such as curl-impersonate, curl_cffi and uTLS rebuild Chrome's ClientHello outside the browser. Pick a profile for the Chrome version your User-Agent claims, update both together, and run the check above after each update.
- Keep the story consistent. The handshake, the HTTP/2 settings, the headers and the User-Agent all describe one client. Changing only the header is the mismatch these checks look for.
None of this gets a client past every bot check. The IP address, the browser's JavaScript surface and its behavior all count too. But the handshake is the first thing a server sees, and it is the cheapest one to get right.
Sources
- Protecting Chrome Traffic with Hybrid Kyber KEM, Chromium blog, August 2023
- Intent to Ship: X25519Kyber768 key encapsulation for TLS on Desktop, blink-dev, March 2024
- A new path for Kyber on the web, Google Online Security blog, September 2024
- draft-ietf-tls-ecdhe-mlkem, IETF: codepoint 4588 (0x11EC), client share 1,216 bytes
- tldr.fail: servers that read a large ClientHello in one call
- Go 1.23 and Go 1.24 release notes, crypto/tls
- OpenSSL 3.5 release notes, 8 April 2025
- JA4 technical details, FoxIO
- Our captures: tls.peet.ws/api/all and Cloudflare's
/cdn-cgi/trace, 17 November 2026