Skip to main content

TLS fingerprinting

Fingerprinting/General

Also known as TLS fingerprint, JA3, JA4

TLS fingerprinting identifies an HTTP client by the details of its TLS handshake: the cipher suites, extensions and their order in the ClientHello. Because this happens before any HTTP header is sent, changing the User-Agent does not change the fingerprint.

How to recognize it

How to recognize it
Symptom
Blocks persist whatever headers or User-Agent you send
Symptom
The same request works from Chrome on the same IP but fails from your HTTP library
Client
Default HTTP libraries: Python requests, Node axios, Go net/http

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 h2 and http/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

  1. 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.
  2. Open the same service in the Chrome version your User-Agent claims.
  3. Compare the JA4 and the HTTP/2 values. Ignore differences in JA3 caused by extension order.
  4. 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.

Questions

What is TLS fingerprinting?

TLS fingerprinting identifies the software behind an HTTPS connection from its ClientHello, the first unencrypted message of the TLS handshake. The cipher suites, extensions and their order differ between browsers and HTTP libraries, so the server can tell them apart before any HTTP header is sent.

What is the difference between JA3 and JA4?

JA3 hashes the ClientHello fields in the order the client sent them, so a client that shuffles its extensions, as current Chrome does, gets a different JA3 on every connection. JA4 sorts the cipher and extension lists before hashing, ignores GREASE values and adds a readable prefix, which keeps it stable for Chrome.

How can I check my TLS fingerprint?

Send a request from your client, through your real proxy, to a TLS echo service such as tls.peet.ws or browserleaks.com/tls, and open the same page in the Chrome version your User-Agent claims. Compare the JA4 and HTTP/2 values.

Why doesn't changing my User-Agent fix TLS fingerprint blocks?

The User-Agent is sent after the TLS handshake. Changing it does not change the ClientHello, and a Chrome User-Agent on a non-Chrome handshake makes the mismatch even more obvious.

Does a proxy change my TLS fingerprint?

A normal tunnelling proxy does not; your client still performs the handshake with the site. A proxy that terminates TLS and opens its own connection, such as Charles with SSL proxying turned on, replaces your fingerprint with its own.

Further reading

Technical review: Hyper Solutions engineering, Nov 18, 2026