What the ClientHello gives away
Every HTTPS connection starts with a ClientHello: the first message your client sends, before anything is encrypted. That message is what TLS fingerprinting reads. It lists what the client supports, and every TLS library fills it in its own way:
- the TLS versions it offers;
- the cipher suites, in order of preference;
- the extensions, and the order they appear in;
- the supported groups (curves) and signature algorithms;
- the ALPN values, for example
h2andhttp/1.1.
Chrome, Firefox, Safari, Python's requests, Node's axios and Go's net/http all produce different combinations. A server, or the anti-bot service in front of it, reads the ClientHello and knows which family of software is connecting before a single HTTP header has been sent.
JA3 and JA4
The fingerprint is usually written down in one of two standard formats.
JA3 was published by Salesforce in 2017. It takes the TLS version, cipher suites, extensions, curves and point formats exactly in the order the client sent them and hashes the result with MD5. Because it depends on order, a client that shuffles its extensions produces a different JA3 on every connection. Current Chrome versions do exactly that, so a single JA3 string is no longer a reliable way to recognize Chrome.
JA4 was published by FoxIO in 2023. It starts with a readable prefix: protocol, TLS version, whether a server name was sent, the number of cipher suites and extensions, and the first and last character of the first ALPN value. That prefix is followed by short hashes of the cipher suites and of the extensions plus signature algorithms. The cipher and extension lists are sorted before hashing, the signature algorithms keep their order, and the random GREASE values are ignored. So Chrome's shuffled order still gives a stable JA4.
For a scraper, the lesson is that matching one JA3 string is not the goal. The handshake as a whole has to look like the Chrome version your User-Agent claims.
The second layer: the HTTP/2 fingerprint
Right after the handshake, an HTTP/2 client sends its connection settings, a window update and the headers of its first request. The values and order of those settings and the order of the pseudo-headers differ between clients too. Chrome sends its pseudo-headers as :method, :authority, :scheme, :path. A request that has a Chrome TLS fingerprint but HTTP/2 frames from another library is as easy to spot as one with the wrong TLS fingerprint. The header order docs cover the header side.
Why changing the User-Agent does not help
The User-Agent is an HTTP header. It is sent after the TLS handshake, inside the encrypted connection. Changing it changes what your client says it is, not how it connects. A request that claims to be Chrome in the User-Agent but connects with Python's TLS stack is a stronger automation signal than either part on its own. The same applies to client hints: they have to agree with the User-Agent and with the handshake.
How to check your own TLS fingerprint
- Send a request from your client, through the proxy you actually use, to a TLS echo service such as tls.peet.ws or browserleaks.com/tls. Both show the JA3 and the JA4 of the connection. tls.peet.ws also shows the HTTP/2 fingerprint. On BrowserLeaks, that is on browserleaks.com/http2.
- Open the same service in the Chrome version your User-Agent claims.
- Compare the JA4 and the HTTP/2 values. Ignore differences in JA3 caused by extension order.
- Repeat the test through any debugging proxy you use. A proxy that decrypts TLS opens its own connection to the site. Charles does this with its own handshake, which replaces your fingerprint. powhttp copies your client's handshake, so the fingerprint barely changes. A plain tunnelling proxy leaves the handshake untouched.
What a TLS fingerprint does not prove
- It identifies client software, not a person. Millions of Chrome users share the same fingerprint.
- A matching fingerprint is necessary, not sufficient. Header order, client hints, cookies, IP reputation and the anti-bot challenges are checked as well.
- It does not change with every browser release. Chrome's handshake can stay the same across several versions, so a client profile named after an earlier Chrome version can still match a newer User-Agent. What has to match is the handshake the claimed version really sends.
- A fingerprint that changes mid-session is a signal of its own. Keep the client, its profile and the User-Agent the same from the first request to the last.
Getting a Chrome-like handshake
Default HTTP libraries cannot reproduce Chrome's ClientHello. The Hyper Solutions TLS fingerprinting docs recommend a browser-matching client such as tls-client or azuretls-client, configured with the latest Chrome profile it ships, random extension order enabled and HTTP/3 disabled. That is the first of the core requirements for request-based scraping.