TLS And HTTP2 Handshake Fingerprints: What Your Connection Says Before The Page Loads
Before a page sends you a single byte of HTML, your browser has already introduced itself in detail. It did that in the first packet of the encrypted connection, a message called the ClientHello, which lists the encryption methods it supports, in its own preferred order, along with a dozen or so extensions. Chrome writes that message one way. Firefox writes it another way. A Python script writes it a third way. None of this involves JavaScript, cookies or anything a browser extension can touch. It’s the transport layer, and it’s the one part of the fingerprint most people running multiple accounts have never looked at. This piece covers what the handshake reveals, how the JA3 and JA4 style hashes summarise it, what HTTP/2 adds on top, and the specific ways a proxy chain or an automation setup ends up disagreeing with the browser it claims to be.
The layer underneath the page
Most fingerprinting talk is about what JavaScript can read once the page loads: canvas, fonts, screen size, the user agent. All of that happens after the connection is set up.
The connection itself comes first, in three rough stages. A TCP connection opens between your device, or your proxy, and the server. Then TLS negotiates encryption, which is where the ClientHello goes out. Then the HTTP conversation starts, today usually over HTTP/2, which has its own opening settings. Only after all of that does the server send a page, and only after the page arrives can any fingerprinting script run.
Each of those stages carries information about the software on the client side. None of it is secret or exotic. It has to be sent in the clear, or at least readable by the server, for the connection to work at all. The server needs to know which ciphers you support in order to pick one.
That’s what makes this layer interesting. It’s observed passively, by the server or the network in front of it, on every single request. It can’t be blocked without breaking the connection. And it’s produced by the networking code inside the browser or client, which antidetect tools usually don’t rewrite, because rewriting it properly means changing the browser’s TLS library.
For most operators the practical question is whether the handshake agrees with the rest of the story. A connection that presents Chrome’s handshake and then runs a page claiming Chrome is consistent. A connection that presents something else while claiming Chrome is not, and that contradiction is visible before your profile has done anything at all.
What the ClientHello contains
The ClientHello is the opening message of a TLS handshake. It’s sent before encryption begins, which is why a server, a CDN or a middlebox can read it.
It lists the TLS versions the client supports. It lists the cipher suites the client is willing to use, in order of preference. It lists extensions, which are optional features: server name indication, which says which site you’re connecting to, supported groups for key exchange, signature algorithms, the application protocols the client can speak, key shares for the exchange itself, and several more besides. Each extension appears in a particular order, with particular contents.
Every TLS library builds this message differently. Chrome uses its own library, BoringSSL, and builds a ClientHello with its own choice and order of ciphers and extensions. Firefox uses NSS and builds a different one. Safari uses Apple’s stack. Command line tools and programming languages use OpenSSL, Go’s crypto library or others, and each has its own defaults.
Chrome also inserts GREASE values, which are deliberately meaningless entries placed in lists like the cipher suites and extensions. They exist to stop servers from breaking when new values appear in future, and Chrome picks them randomly per connection. Their presence and position is itself characteristic of Chromium based browsers.
So the ClientHello is a detailed statement of which TLS library, and roughly which version of it, opened the connection. It doesn’t identify you as a person. It identifies the software family, and very often the browser version range. For multi account work, that’s exactly the level where contradictions show up.
JA3 and why it broke
Reading a whole ClientHello is unwieldy, so defenders summarise it. The best known summary is JA3, published by researchers at Salesforce in 2017.
JA3 takes a few fields from the ClientHello, namely the TLS version, the list of ciphers, the list of extensions, the supported groups and the point formats. It writes them out as numbers in the order they appeared, joins them into a string, and hashes that string with MD5. The result is a 32 character hash that stays the same for a given client build and changes when the client’s TLS behaviour changes.
For several years JA3 was a practical way to recognise clients. Security teams kept lists of JA3 hashes for common malware, for scraping libraries and for ordinary browsers. A request arriving with a JA3 belonging to a Python library while claiming to be Chrome stood out.
Then in early 2023 Chrome started randomising the order of its TLS extensions on each connection. The contents stayed the same, but the order changed, and JA3 depends on order. Every Chrome connection began producing a different JA3 hash. That made JA3 far less useful for identifying Chrome, though it still works for many other clients that don’t randomise.
The randomisation wasn’t aimed at fingerprinting as such. It was meant to stop servers from depending on a fixed order. But it pushed the defensive side to build a better summary, and it’s a good example of why any single hash format has a shelf life.
JA4 and the newer family
The successor most people now refer to is JA4, released by FoxIO in 2023. It was designed with Chrome’s randomisation in mind.
JA4 sorts the cipher and extension lists before hashing them, so reordering doesn’t change the result. It also produces a readable prefix before the hashed parts. That prefix records whether the connection is TCP or QUIC, the highest TLS version offered, whether a server name was sent, how many ciphers and extensions were offered, and the first application protocol the client asked for, such as HTTP/2. You can often tell a lot about a client from that prefix before you look at the hashes at all.
JA4 is part of a wider family with the same naming style. There are variants for HTTP request headers, for the server’s side of the handshake, for TCP characteristics and others. Not all of them are used everywhere, and some carry different licensing terms. The important thing for an operator is the idea they share. Summarise how the client’s networking code behaves, in a form that’s stable across harmless variation and changes when the software changes.
Large CDNs and bot management products expose these kinds of fingerprints to the sites they protect, so a site owner can write rules against them. Which rules any particular platform writes, and how much weight it gives the results, isn’t public.
What you can say confidently is that a site behind a modern CDN can see, for every request, a stable summary of which TLS stack you’re using. If your profile claims to be Chrome, that summary had better look like Chrome’s.
What HTTP/2 adds
Once TLS is set up, the client and server usually agree to speak HTTP/2. HTTP/2 opens with its own exchange, and that exchange is another fingerprint.
The client sends a SETTINGS frame with values like the header table size, whether server push is enabled, the initial window size and the maximum header list size. Different clients pick different values. It often sends a WINDOW_UPDATE frame to enlarge the connection’s flow control window, and the size of that increment varies by client. Some clients send PRIORITY information about how streams depend on each other. Then there are the four pseudo headers that begin each request. Method and path are two of them, authority and scheme the other two, and different browsers send them in different orders.
Akamai researchers described a passive HTTP/2 fingerprint built from these values at Black Hat in 2017, and variations of that idea are in wide use now. It works for the same reason the TLS fingerprint does. The values come from the client’s networking code, and most people never change them.
Normal HTTP headers add a little more. Browsers send headers in a consistent order and with a consistent set, such as the accept headers, the encoding header, and in Chromium the client hint headers. A request whose header order doesn’t match the browser it claims to be adds to the picture.
Put the TLS and HTTP/2 fingerprints side by side and you have a strong read on the client software, all gathered before the first line of the page loads.
How a scripted client gives itself away
The clearest case of a transport mismatch is a script that sends a browser’s user agent string.
Suppose someone writes a script with a common HTTP library and sets the user agent header to a current Chrome string. The header says Chrome. But the TLS handshake is built by the library’s TLS stack, which proposes a different set of ciphers, in a different order, with different extensions and no GREASE. The application protocol may be HTTP/1.1 only, since many libraries don’t speak HTTP/2 by default. The headers arrive in the library’s order, not Chrome’s.
To the server, that request has a Chrome label stuck on a non browser connection. No JavaScript needs to run to see it. Many bot management setups catch this class of request at the edge, before it reaches the application.
This matters to multi account operators in a few places. Some people run account checks, balance lookups or posting through scripts instead of a real browser, for speed. Some tools that claim to be “browserless” do the same. And some automation hits a platform’s API endpoints directly from a script while the same account normally uses a browser. In each case the account’s traffic suddenly comes from a different kind of client.
There are libraries that try to imitate a browser’s handshake closely. They exist, and they’re used for scraping. I’m not going to walk through them. The point for account work is simpler. If an account lives in a browser profile, keep its traffic in that browser. A second client type touching the same account is a second fingerprint attached to one identity.
How a proxy can change the handshake
Most operators assume the proxy only changes the IP address. For ordinary proxies that’s true of the TLS layer, and it’s worth understanding why, because the exceptions matter.
An HTTP proxy handling a secure site works through a CONNECT request. The browser asks the proxy to open a tunnel to the server, and then the browser performs its TLS handshake through that tunnel. The proxy passes bytes along without reading them. SOCKS proxies behave the same way. In both cases the server sees the browser’s own ClientHello, and the proxy only changes where the connection comes from.
The exception is any setup that terminates TLS in the middle. Some corporate networks inspect encrypted traffic by decrypting it and re-encrypting it. Some antivirus products do the same on the local machine to scan web traffic. Some debugging tools do it. A few proxy services have run gateways that re-originate connections rather than tunnelling them. In every one of these cases the server sees the handshake of the middlebox, not the browser. The page’s JavaScript says Chrome, and the transport says some other TLS stack entirely.
If you use a proxy service, you can check which kind you have. If the handshake a fingerprint echo page shows you matches what your browser produces on a direct connection, the proxy is tunnelling. If it’s different, something in the chain is terminating TLS.
Antivirus HTTPS scanning on the host is the one people miss most, because it’s switched on by default in some products and nobody thinks of it as a proxy.
When the browser core and the claim disagree
The other mismatch comes from inside the antidetect tool itself.
Every antidetect browser runs on a real engine, usually Chromium, sometimes Firefox. Its TLS handshake comes from that engine’s networking code. The tool can set whatever user agent string you like, but unless it has modified the TLS library, the handshake is the handshake of the engine it’s built on.
That creates two common contradictions. The first is version drift. The tool’s core is a Chromium release from some months ago, and the profile’s user agent claims the current Chrome version. For many releases the TLS handshake doesn’t change, so this is often invisible. When Chrome does change something in its handshake, for example adding support for a new key exchange method, older cores keep presenting the older handshake while claiming the newer version.
The second is engine mismatch. A profile running on a Firefox based core that claims to be Chrome presents a Firefox handshake, with NSS’s ciphers and extensions, under a Chrome user agent. HTTP/2 settings and pseudo header order give it away as well. No amount of JavaScript side spoofing fixes that, because it happens before JavaScript runs.
The practical rule is to claim the engine you’re running. If your profiles run on a Chromium core, claim a Chromium browser at a version close to the core’s real version. If they run on a Firefox core, claim Firefox. Keep your tool updated so the core doesn’t fall far behind the version it claims.
QUIC and HTTP/3
Modern browsers don’t only use TCP. For many large sites, Chrome and other browsers also speak HTTP/3, which runs over QUIC, a transport built on UDP. A browser typically learns that a site supports HTTP/3 from a header on an earlier response, then tries QUIC on later connections and falls back to TCP if it fails.
QUIC carries its own TLS handshake inside it, so the same kind of ClientHello fingerprinting applies. JA4 even records whether a connection arrived over TCP or QUIC in its first character.
For proxy users, the interesting part is what happens when QUIC can’t get through. An HTTP proxy tunnel carries TCP only. Many SOCKS setups don’t relay UDP either. So a browser behind such a proxy tries QUIC, fails, and stays on TCP with HTTP/2. That’s completely normal. Plenty of real networks block UDP on the relevant ports, including a lot of corporate and some public networks, so sites see browsers falling back all the time.
Where it gets messier is a partial path. If the proxy handles TCP but the browser’s UDP traffic can reach the internet directly, a QUIC connection could leave through your real connection while everything else goes through the proxy. That’s a leak in the same family as the WebRTC and DNS leaks people already know about. Most antidetect tools disable QUIC for proxied profiles, or force it through the same route. It’s worth confirming yours does, by checking in a site’s network panel or a checker which protocol each request used.
The protocol choice between SOCKS5 and HTTP proxies, and how each handles UDP, is its own topic. For the handshake question, the rule is the same as everywhere else. All of an identity’s traffic should leave through one route and present one client.
The TCP layer beneath it all
Underneath TLS, the TCP connection carries its own faint fingerprint, and here a proxy changes things in a way operators should understand.
The very first packet of a TCP connection includes a few values that differ by operating system: the initial time to live, the window size, and the set and order of TCP options. Tools like the long standing p0f project have used these to guess a client’s OS passively for years. Windows typically starts with a time to live of 128. Linux, Android and macOS typically start at 64.
When you use a proxy, the server’s TCP connection comes from the proxy’s exit, not from your machine. So the server sees the TCP fingerprint of whatever the proxy runs on. Most proxy servers run Linux. A mobile proxy running on a modem host is usually Linux too. So a Windows profile behind almost any proxy presents a Linux looking TCP fingerprint with a Windows browser on top.
That sounds alarming, but it’s also extremely common in ordinary traffic, because people browse through corporate proxies, carrier equipment and home routers of every kind. A TCP OS guess that disagrees with the browser is a weak signal on its own, and a platform that leaned hard on it would flag huge numbers of real users.
It does become meaningful when it stacks with other things, or when it agrees with them in a way that fits a story. An Android phone on a real mobile network presents a Linux family TCP fingerprint, a Chrome for Android handshake and an Android user agent. Everything lines up, because the device and the network really are what they say.
Reading a TLS fingerprint checker
You can see your own handshake. Several free pages echo back what your connection sent. BrowserLeaks has a TLS page, and tls.peet.ws shows the ClientHello, a JA3 hash, a JA4 string and HTTP/2 details in one place. Others exist, and they differ in which formats they show.
Here’s how to read one without drawing the wrong conclusion.
Ignore the JA3 hash for Chrome. It changes every connection because of extension randomisation, so two different JA3 hashes from Chrome mean nothing.
Look at the JA4 string instead. Load the page in a plain, up to date copy of Chrome on the same machine with no proxy. Note the JA4. Then load it in your antidetect profile. If the profile claims Chrome and runs on a Chromium core, the JA4 should match or be very close. If it’s completely different, find out why.
Check the application protocol. A real browser on a modern site should negotiate HTTP/2. If the checker says HTTP/1.1, something in the chain may be downgrading the connection.
Check the HTTP/2 section if there is one. Compare the settings values and the pseudo header order between plain Chrome and your profile.
Then repeat the profile check through the proxy. If the handshake changes when the proxy is on, the proxy or something on your machine is terminating TLS.
A worked example of a mismatched chain
Here’s a hypothetical setup to show how the pieces combine.
An operator runs profiles in an antidetect tool on a Windows machine. The profiles claim a current Chrome version. They go out through a residential proxy service. The machine has an antivirus suite with web scanning switched on, which nobody has thought about since it was installed.
On a checker, the JavaScript side looks fine. Canvas is stable, fonts are Windows fonts, the user agent claims current Chrome.
The TLS checker tells a different story. The ClientHello has no GREASE and a cipher list that doesn’t look like BoringSSL. The application protocol is HTTP/1.1. That’s the antivirus product decrypting and re-encrypting every HTTPS connection with its own TLS stack. Every profile on that machine, whatever proxy it uses, presents the same non browser handshake.
That last part is the bigger problem. It’s a contradiction for each profile, and it’s also a shared trait across all of them. Every account on the machine now carries the same unusual transport fingerprint, which a platform can group on.
The fix takes minutes. Turn off the antivirus product’s HTTPS scanning, or exclude the antidetect browser from it, then re-run the checker. The handshake should match plain Chrome’s. If it still doesn’t, test without the proxy to see whether the proxy is the next suspect.
Why a fleet can share one transport fingerprint
There’s a side of this that matters more for fleets than for a single account.
A TLS fingerprint doesn’t identify a person. Millions of people run the same Chrome version, so millions of connections share the same JA4 string. In that sense it’s a weak identifier, and for ordinary browsers that’s fine. Sharing Chrome’s handshake with the whole world is exactly what you want.
The trouble starts when a fleet shares a handshake that the rest of the world doesn’t. An older Chromium core that ships with one antidetect tool. A TLS terminating gateway on one proxy service. A security product on one host. Each of those gives every profile that passes through it the same unusual transport fingerprint.
At that point the handshake stops being a crowd and becomes a label. A platform that sees a set of accounts all arriving with a fingerprint rare in its overall traffic has a cheap way to group them, whatever their IPs and canvas hashes say. It doesn’t need to know what the fingerprint means. It only needs to notice that these accounts have it and most accounts don’t.
This is also why transport level changes can hit many accounts at once. If a tool’s core falls far enough behind current Chrome, every profile running on it drifts away from the crowd together. When the tool updates, they all move back together. Nobody sees any of it in the JavaScript fingerprint.
So when you test, compare your profiles against plain Chrome as well as against each other. Matching each other is expected, since they run on the same engine. Matching plain Chrome is the part that keeps them inside the big crowd.
What you can and can’t change
It’s worth being clear about which parts of this are in an operator’s hands.
You can choose the engine your profiles run on, and claim that engine honestly. You can keep the tool updated so its core stays close to the version it claims. You can remove anything on the host that intercepts TLS. You can pick proxies that tunnel rather than terminate. You can keep account traffic inside the browser instead of splitting it between the browser and scripts.
You can’t choose the proxy’s TCP fingerprint in any practical sense, and you shouldn’t worry much about it. You can’t stop the server from reading your handshake, because the connection can’t work without it. And you can’t see what weight any platform gives these signals. They’re used heavily at the CDN and bot management layer, and how that feeds into account level decisions varies by platform and changes without notice.
Every real browser has a handshake, so there’s nothing to hide in having one. What you want is that yours looks like the browser your profile claims to be, and that it doesn’t carry a strange trait shared by your whole fleet.
What to do this week
If you’ve never looked at this layer, here’s a short list that covers most of the ground.
Run a TLS checker in plain Chrome, then in one of your profiles, then in that profile through its proxy. Compare the JA4 strings and the application protocol. Three loads, five minutes.
Check the host for anything that scans HTTPS. Antivirus web shields, corporate security agents, debugging proxies you installed once and forgot. Switch off the interception or exclude the browser.
Confirm your profiles claim the engine they run on. A Chromium core should claim Chrome or another Chromium browser. A Firefox core should claim Firefox.
Look at where your account traffic comes from. If some jobs run through scripts or direct API calls while the account otherwise lives in a browser, decide whether that split is worth the second fingerprint.
Write the results down with the date, in the same log where you keep your profile checks. When your tool updates its core, run the three loads again.
The honest limit
The transport layer is one set of evidence among many. A clean, consistent handshake doesn’t protect an account that has problems elsewhere, and a handshake mismatch alone rarely decides an account’s fate. I don’t know how any particular platform weighs these signals today, and the public documentation from CDN vendors describes what’s available to their customers, not what each customer does with it.
What I can say is that this layer is observed on every request, before any page loads, and that most multi account guides skip it entirely. A profile that’s been carefully built on the JavaScript side and then sent out through an antivirus proxy or claimed as the wrong engine has a contradiction baked in at the very first packet.
The network underneath matters for the same reason. A proxy that tunnels cleanly and exits through a real residential or mobile address keeps the transport story simple. The identities I care most about sit on real phones on real mobile connections, where the handshake, the TCP layer and the device all agree because nothing is being faked.
I run Singapore mobile proxy and cloud phone farms myself, so that’s the stack I’m describing, not a guess. If you want the rest of the network and device picture, start on the Multi Account Ops home page.
Get new guides and videos first — join the Telegram channel.