What Is TLS Fingerprinting?

Last updated 15 November 2026.

TLS fingerprinting is the practice of identifying the software behind a connection from its ClientHello, the first message a client sends to open a TLS session. The cipher suites, extensions and other values it offers reach the server unencrypted, and they differ between browsers, libraries and bots. A fingerprint identifies a client stack, not a person.

Cloudflare's documentation puts the idea in one line: "Each client type (browser, bot, or application) has distinct connection characteristics, so the resulting fingerprint acts as a stable identifier across different destination IPs, ports, and certificates." That stability is what makes the signal useful against bots and fake signups. It is also what limits it, because every client running the same stack looks the same. Trueguard reads this handshake on its own server during each verification session and computes a JA4 and an HTTP/2 fingerprint from it. This page is the overview. The field-by-field detail lives in the JA3 guide and the JA4 and JA4T guide.

What is in a TLS ClientHello?

The ClientHello is the client's opening offer: the protocol versions it supports, the cipher suites it will accept, and a list of extensions. RFC 8446, the TLS 1.3 specification, makes it mandatory: "When a client first connects to a server, it is REQUIRED to send the ClientHello as its first TLS message." The same RFC states that "All handshake messages after the ServerHello are now encrypted." The ClientHello comes before the ServerHello, so the server that terminates the connection can read every field.

RFC 8446 defines the message as:

struct {
    ProtocolVersion legacy_version = 0x0303;    /* TLS v1.2 */
    Random random;
    opaque legacy_session_id<0..32>;
    CipherSuite cipher_suites<2..2^16-2>;
    opaque legacy_compression_methods<1..2^8-1>;
    Extension extensions<8..2^16-1>;
} ClientHello;

The version at the top is fixed at 0x0303 for compatibility. The real version sits in the supported_versions extension, and FoxIO's JA4 specification reads it from there: "If extension 0x002b exists (supported_versions), then the version is the highest value in the extension. Remember to ignore GREASE values." GREASE values are reserved random values that clients add on purpose, which the JA3 guide covers in detail.

Most of the signal sits in the cipher list and the extensions. The extensions include the server name (SNI), the application protocols the client wants (ALPN), and the signature algorithms it supports. JA4 uses the presence of SNI, the first ALPN value, the cipher and extension counts, the sorted cipher list, and the sorted extension list plus signature algorithms. Each of these is set by the TLS library and its configuration. That is what a fingerprint records.

What changes with Encrypted Client Hello?

Encrypted Client Hello (ECH), published as RFC 9849 in March 2026, splits the message in two. The RFC describes it this way: "When a client wants to establish a TLS session with some backend server, it constructs a private ClientHello, referred to as the ClientHelloInner. The client then constructs a public ClientHello, referred to as the ClientHelloOuter." The outer hello carries the encrypted inner one. The RFC names the SNI and the ALPN list among the fields it protects.

The server that receives the outer hello either decrypts the inner one and forwards it to the backend server ("accepting ECH"), or completes the handshake with the outer hello ("rejecting ECH"). When building the outer hello, the client "MAY copy any other field from the ClientHelloInner except ClientHelloInner.random." RFC 9849 does not discuss fingerprinting, and the JA4 specification did not mention ECH as of 15 November 2026. What follows is inference from the RFC's design: an observer on the path still sees a ClientHello in the clear, the outer one, while a server that decrypts ECH has the inner one to work with. The RFC also notes that implementation choices "such as extension ordering within TLS messages" can produce "different externally visible behavior."

How do JA3, JA4 and HTTP/2 fingerprints differ?

JA3 and JA4 both read the ClientHello. JA3 hashes fields in the order sent, while JA4 sorts them first and keeps a readable prefix. The Akamai HTTP/2 fingerprint works one layer up, on the frames a client sends after the TLS handshake.

JA3 was created at Salesforce in 2017. It takes five ClientHello fields in wire order and hashes them with MD5 into 32 characters. Chrome's extension reordering broke its stability, and Salesforce has archived the repository. See how a JA3 hash is built.

JA4 was launched by FoxIO in September 2023. It sorts ciphers and extensions before hashing, which Cloudflare says "reduces the number of unique fingerprints for modern browsers and makes grouping easier." It belongs to the wider JA4+ suite, which adds server, HTTP, certificate, TCP and other methods. See JA4 and JA4T, field by field.

The Akamai HTTP/2 fingerprint comes from a June 2017 white paper by Ory Segal, Aharon Fridman and Elad Shuster at Akamai. The authors found "a consistent variation" in three parts of an HTTP/2 connection: the SETTINGS, WINDOW_UPDATE and PRIORITY frames. Their format joins those values, plus the order of the pseudo-headers, into a plain-text string. The paper's example for Chrome 58 on Windows 10 is 1:65536;3:1000;4:6291456|15663105|0. The open-source reverse proxy fingerproxy is one tool that computes it, next to JA3 and JA4.

MethodLayerInputsFormatOrigin and yearStatus as of 15 November 2026
JA3 / JA3STLS ClientHello (JA3S: ServerHello)Version, ciphers, extensions, curves, point formats, in the order sentMD5 hash, 32 hex charactersSalesforce, 2017Repository archived, last push 1 May 2025
JA4TLS ClientHello over TCP, QUIC or DTLSProtocol, version, SNI present or not, counts, ALPN, sorted ciphers, sorted extensions plus signature algorithmsReadable prefix plus two 12-character truncated SHA-256 hashes, 36 charactersFoxIO, September 2023Repository active, last push 12 November 2026. BSD 3-Clause
Other JA4+ methods (JA4S, JA4H, JA4X, JA4T and more)TLS server, HTTP, X.509, TCP, latency, SSH, DHCPPer methodPer methodFoxIO, 2023 onwardSame repository. FoxIO License 1.1, patent pending
Akamai HTTP/2HTTP/2 connectionSETTINGS, WINDOW_UPDATE and PRIORITY frames, pseudo-header orderPlain text, S[;]|WU|P[,]#|PS[,]Akamai, Black Hat EU, June 2017White paper only. No maintained reference implementation found. Computed by third-party tools
ECH (note)Wraps the ClientHelloNot a fingerprint methodNot applicableIETF, RFC 9849, March 2026Standards Track. Encrypts the inner ClientHello

How do teams use TLS fingerprints to stop bots?

One use is a consistency check. A client that claims to be a browser in its User-Agent header should also send a browser's handshake. When the two disagree, the claim is probably false.

The Akamai paper describes the case directly: "an automated web scraping tool, written using the "Go" programming language, may send a spoofed Chrome web browser User-Agent string in order to evade anti-automation protection mechanisms. In these cases, it would be quite simple to detect a spoofing attempt and deduce the real HTTP/2 client type." The same logic applies to a TLS fingerprint. A signup request that says Chrome but opens its connection with a Go library's ClientHello is worth a second look.

Edge platforms expose fingerprints for rules and aggregation. As read on 15 November 2026:

Reputation is the third use. Requests that share a fingerprint can be counted and scored together. F5 sets the rule for acting on it: "We cannot simply block ... based on JA4 fingerprint alone UNLESS we can be certain that ALL (or nearly all) requests with that JA4 are malicious." For fake signups, that makes a fingerprint one input next to the IP address, the email and the device. It rarely justifies a block on its own.

What can a TLS fingerprint not tell you?

A TLS fingerprint cannot tell you who is behind a connection. It identifies the software stack, it can be copied, it changes when that software updates, and it can belong to a middlebox instead of the client.

F5's write-up is explicit: "a JA4 TLS fingerprint, or any TLS fingerprint for that matter, is NOT a fingerprint of an individual instance of a device or browser. Rather, it is a fingerprint of a TLS "stack" or application. For example, all Chrome browsers of the same version and the same operating system will generate the same JA4 fingerprint." Akamai said the same of HTTP/2 in 2017: "The HTTP/2 fingerprint, by itself, does not provide enough entropy to fingerprint or track specific users." Cloudflare reports analyzing over 15 million unique JA4 fingerprints a day, generated from more than 500 million user agents. We found no published figure for how many users share one fingerprint.

Fingerprints also age. FoxIO's README warns: "JA4 fingerprints will change as application TLS libraries are updated, about once a year." Cloudflare's 2024 post on JA4 Signals adds: "Fingerprints can be easily spoofed, they change frequently, and traffic patterns and behaviors are constantly evolving."

The spoofing tools are public, and three of the four below were updated in 2026. As of 15 November 2026:

Akamai's 2017 observation that "many HTTP/2 clients don't support modification of basic HTTP/2 implementation details" predates these tools. It should be read as dated.

The last limit is the network path. RFC 8446 requires that a middlebox which terminates TLS "MUST generate its own ClientHello containing only parameters it understands." A CDN, a load balancer or a corporate inspection proxy in front of your server therefore sends its own handshake onward. Fingerprint at the server behind it and you measure the middlebox.

Does a VPN change your TLS fingerprint?

In most cases, no. A VPN carries the client's packets through a tunnel, and a proxy that relays a connection with HTTP CONNECT passes the bytes along. In both cases the ClientHello is still produced by the client's own TLS stack. This follows from how the tunnel works. No source we read measures it in those words.

The Akamai paper supports the proxy case. Under a "Proxy or VPN" use case, it describes an anonymizing proxy that "does not terminate TLS and does not terminate and rewrite HTTP/2 traffic". In that case, "the TCP fingerprint will show that a Windows 10 machine was connecting to the web server, while the TLS and HTTP/2 fingerprints will expose the fact that the client is actually running a Chrome browser on Mac OS X." The same applies to a bot rotating through residential proxy exit addresses: the IP address changes, while the handshake stays the same unless the bot changes its TLS client.

The exception is a proxy that terminates TLS. Under RFC 8446, section 9.3, it must open a new connection with its own ClientHello, so the server sees the proxy's fingerprint. A fingerprint therefore says little about the network path. That question needs IP data.

Is TLS fingerprinting legal under GDPR?

No European or UK regulator guidance we found names TLS fingerprinting. The guidance addresses device fingerprinting in general, mostly under ePrivacy rules (Article 5(3) of the ePrivacy Directive, and PECR in the UK) alongside data protection law. This section describes what the documents say. It is not legal advice.

The EDPB's Guidelines 2/2023 (version 2.0, adopted 7 October 2024) confirm that "fingerprinting falls within the technical scope of Article 5(3) ePD". They add that relying on protocol mechanisms such as HTTP headers "to collect information (for example in the context of fingerprinting or the tracking of resource identifiers) can lead to the application of Article 5(3) ePD." The guidelines do not mention TLS, ClientHello, JA3 or JA4, and they state they do not address when the consent exemptions apply.

The ICO finalised its guidance on storage and access technologies on 29 April 2026. It covers device fingerprinting and lists elements that include "data exposed by the use of particular network protocols" and "TCP stack variation". It does not name the TLS ClientHello. The guidance includes an example of fingerprinting used to detect fraudulent account creation. In a December 2024 blog post, the ICO wrote that "businesses do not have free rein to use fingerprinting as they please" and that "Data protection law, including the Privacy and Electronic Communications Regulations (PECR), applies."

Whether a server reading the ClientHello it receives falls under these rules is not settled in the documents. Take that question to counsel with the specific use case.

How Trueguard handles this

Trueguard runs its own TLS-terminating fingerprint service. During a verification session, the Trueguard SDK makes a request to that service, which reads the TLS ClientHello and HTTP/2 settings from the connection. It computes a JA4 fingerprint and an HTTP/2 fingerprint, records the User-Agent the client claims, and links the result to the verification id. Trueguard combines this with the browser fingerprint, IP data and email signals into one risk score your backend reads. Because TLS terminates at Trueguard's own service, a CDN in front of your site does not hide the client's handshake from it. See how this applies to fake account prevention.

Start free with 1,000 verification events per month. Get a free key

Frequently Asked Questions

Yes. Tools such as uTLS, curl-impersonate and curl_cffi are built to send a browser-like ClientHello, and some also copy browser HTTP/2 fingerprints. That is why a fingerprint works best checked against other signals. Trueguard computes a JA4 and an HTTP/2 fingerprint from the handshake and records the User-Agent the client claims, so the claim and the handshake sit side by side in one verification.

No. F5 describes a TLS fingerprint as "a fingerprint of a TLS "stack" or application," and notes that all Chrome browsers of the same version on the same operating system produce the same JA4. It narrows a connection to a client stack. Identifying a user takes other data.

JA3 hashes five ClientHello fields with MD5 in the order the client sent them, so reordering changes the hash. JA4, launched by FoxIO in September 2023, sorts ciphers and extensions before hashing and keeps a readable prefix. Salesforce has archived JA3. The FoxIO JA4 repository was active as of 15 November 2026.

RFC 9849 does not address fingerprinting. ECH encrypts an inner ClientHello inside an outer one and protects fields such as SNI and ALPN. The outer hello is still sent in the clear, and a server that accepts ECH decrypts the inner hello. What a given fingerprinting system sees after ECH depends on where it sits.

Usually not. A VPN or a relaying proxy carries the client's own handshake, so the IP address changes while the ClientHello stays the same. A proxy that terminates TLS is different: RFC 8446 requires it to send its own ClientHello.

As read on 15 November 2026, AWS WAF exposes JA3 and JA4 for CloudFront distributions and Application Load Balancers, and Cloudflare exposes them to Enterprise customers with Bot Management. Open-source tools such as fingerproxy compute JA3, JA4 and an Akamai HTTP/2 fingerprint and pass them to a backend as request headers.

Trueguard Basic is free.

Start identifying visitors and signals right away, for free

Sign up for free

No credit card required.

trueguard-logo© 2026 Trueguardinfo@trueguard.io