What is TLS fingerprinting?
Definition
Identifying the software behind a connection from its TLS ClientHello, which is sent in the clear before any HTTP header.
The ClientHello is written by the TLS library, not by your code, so it identifies the library whatever your headers say. A CONNECT proxy relays it byte for byte; only a proxy that performs TLS interception replaces it with its own. The full measurement, seven HTTP libraries and a browser captured at the byte level, is the proxy.wiki study Chromium varied all 12 captured handshakes. curl and Go stayed the same across 3 each. This entry shows what the message looks like and what a server reads from it.
What the server receives
This is the first record curl 8.7.1 sent to a raw TCP listener on our machine, annotated. Offsets are hexadecimal. None of it is encrypted, because encryption has not started yet.
offset bytes field
0000 16 record type 0x16, handshake
0001 03 01 record version (legacy)
0003 01 28 record length 296
0005 01 handshake type 0x01, ClientHello
0006 00 01 24 handshake length 292
0009 03 03 legacy_version
000b 60 54 c2 b3 3c 99 65 0c ... random, 32 bytes
002b 20 94 4b 8e 5f 0a 27 0e ... session id, 32 bytes
004c 00 62 13 03 13 02 13 01 ... cipher suites, 98 bytes = 49 suites
00b0 01 00 compression methods: null only
00b2 00 79 extensions, 121 bytes in total
00b4 00 2b ... 43 supported_versions
00c1 00 33 ... 51 key_share, one X25519 key
00eb 00 0b ... 11 ec_point_formats
00f1 00 0a ... 10 supported_groups
00ff 00 0d ... 13 signature_algorithms
011b 00 10 ... 16 application_layer_protocol_negotiation
The random value and session id change on every connection and carry no identity. Everything else is the library’s fixed choice: which cipher suites it offers and in what order, which extensions, which groups and signature algorithms. A fingerprint is built from those. JA3, the best-known scheme, joins the TLS version, ciphers, extensions, elliptic curves and point formats as decimal lists and takes an MD5 hash of the result. JA4 sorts the cipher and extension lists before hashing, so a reordered list still gives the same value.
There is no server_name extension in this capture, and that is correct. The target was an IP address, and RFC 6066 does not allow a literal IP in that field. Against a hostname it would be there, in the clear, naming the site you are about to visit.
Library against browser
The same listener captured two connections from headless Chrome 155, a few seconds apart:
| Field | curl 8.7.1, both captures | Chrome 155, two connections |
|---|---|---|
| ClientHello size | 301 bytes | 1,899 and 1,963 bytes |
| Cipher suites | 49 | 15, plus one GREASE value |
| Extensions | 6 | 16, plus two GREASE values |
| Extension order | 43, 51, 11, 10, 13, 16 in both captures | Different on each connection |
| Key share | One 32-byte X25519 key | X25519MLKEM768 with a 1,216-byte key, plus X25519 |
| Unregistered extension numbers | None | 17613 and 51764 |
The browser is the one that varies in this comparison. Chrome shuffles its extension order on every connection, so a hash over the order as sent, like the original JA3, gives a new value each time; sorting first, as JA4 does, removes that. The sampled curl client kept the identical structure in both captures, which made it easy to recognise while the browser was hard to pin to a single hash.
Two of Chrome’s extension numbers, 17613 and 51764, do not appear in the IANA TLS ExtensionType registry. GREASE values, defined in RFC 8701, are deliberate dummies that browsers insert so servers keep tolerating values they do not recognise. Their absence is a quick sign that a client is not a mainstream browser.
What changes it, and what does not
Headers, the user agent, the proxy, the country and the exit address all leave the ClientHello untouched. Only changing the TLS implementation changes it: a library built to replay a browser’s handshake, or a real browser engine. Even then the rest of the request has to agree. A browser handshake followed by curl’s three default headers is its own contradiction, measured in What HTTP clients send before you configure anything. For Python clients the options are set out in Using proxies in Python, and for agents in Proxies for AI agents that browse.
Seeing your own
No packet capture is needed. A listener that reads the first record is enough, because the ClientHello arrives before the handshake can fail:
# terminal 1, Python 3.9 or later
python3 -c "import socket;s=socket.create_server(('127.0.0.1',8443));c,_=s.accept();d=c.recv(65536);print(len(d),'bytes',d[:6].hex(' '))"
# terminal 2
curl -sk https://127.0.0.1:8443/
# terminal 1 prints
301 bytes 16 03 01 01 28 01
The full parser that produced the annotated layout above is printed at the end of the study.
How this was captured. 21 October 2026, macOS, curl 8.7.1 and Chrome 155.0.8059.85 in headless mode with a fresh profile, each pointed at a raw TCP listener on 127.0.0.1 that read the first TLS record and closed the connection. Two connections from each client. Extension names are from the IANA registry as updated on 8 October 2026.