Skip to content
Glossary

What is a JA3 fingerprint?

Definition

A JA3 fingerprint is an MD5 hash of five fields from the TLS ClientHello, kept in the order the client sent them.

JA3 is computed from the first message of a TLS connection, before any HTTP header exists, so the user agent you set never gets a say in it. A server or an anti-bot system can match the hash against a list without decrypting anything. This entry covers the format and how it behaves in practice; the measured comparison of browser and library handshakes is in our study, Chromium varied all 12 captured handshakes. curl and Go stayed the same across 3 each.

How the string is built

JA3 takes five fields from the ClientHello, writes each as decimal numbers joined by -, joins the five fields with ,, and hashes the result with MD5. GREASE values are removed first. This is the real ClientHello of curl 8.7.1 on macOS, captured by a local listener:

771,4867-4866-4865-52393-52392-52394-49200-49196-49192-49188-49172-49162-159-107-57-65413-196-136-129-157-61-53-192-132-49199-49195-49191-49187-49171-49161-158-103-51-190-69-156-60-47-186-65-49169-49159-5-4-49170-49160-22-10-255,43-51-0-11-10-13-16,29-23-24-25,0
field 1   771                  TLS version from the ClientHello (0x0303)
field 2   4867-4866-...-255    49 cipher suites, in the order offered
field 3   43-51-0-11-10-13-16  7 extension types, in the order sent
field 4   29-23-24-25          supported groups (x25519, secp256r1, secp384r1, secp521r1)
field 5   0                    EC point formats (uncompressed)

$ printf '%s' "$JA3" | md5     # $JA3 holds the full string above; md5sum on Linux
375c6162a492dfbf2795909110ce8424

Field 1 tells you less than it appears to. RFC 9846, which replaced RFC 8446 as the TLS 1.3 specification, requires a TLS 1.3 ClientHello to put 0x0303, the TLS 1.2 number, in that field and to announce the real version in the supported_versions extension, type 43. Every modern client therefore starts its JA3 string with 771. The only trace of TLS 1.3 in the hash is the number 43 appearing in field 3; the versions offered inside that extension are not part of JA3 at all.

Stable in the sampled libraries, new on every connection for Chrome

We ran the same listener against four clients on macOS 26.6.2, each connecting to https://localhost:

Client Connections Distinct JA3 hashes Hash
curl 8.7.1 3 1 375c6162a492dfbf2795909110ce8424
Python 3.15.0, urllib 3 1 25a66f90ac1f0eb7e775ef1ec9a5d694
Node 24.2.0, global fetch 3 1 983846581fdb62fafdb21d2282592c57
Chrome for Testing 148.0.7778.96, headless shell 12, over 6 launches 12 A different one each time

Chrome sent GREASE values on every connection, and they were stripped before hashing as the JA3 definition requires. The hashes still differed, because Chrome shuffles the order of its extensions. Two consecutive connections, field 3 only:

27-43-65281-45-13-65037-23-10-16-5-51-0-11-35-17613-18
35-43-0-45-51-13-17613-5-11-65037-10-16-23-27-18-65281

Same sixteen extensions, different order, different hash. Sorted, all twelve connections collapsed into one extension set, and the cipher list was identical on every one. A detector that keys on a single JA3 value can therefore pin one of these sampled libraries exactly, while it cannot pin this browser to one hash in this sample. That inversion is the main finding of the ClientHello study, reproduced here with a current Chrome build and full JA3 hashes.

Measured on 21 October 2026: a Python listener on 127.0.0.1 read the first TLS record of each connection, parsed the ClientHello without completing the handshake, removed GREASE values and computed the JA3 string and MD5. The hostname was localhost, so every client sent server_name (type 0); connecting to a bare IP address gives a different hash.

Why JA3 has successors

Extension shuffling is the reason. FoxIO’s JA4 sorts cipher suites and extensions before hashing, so a browser’s reordering no longer produces a new value, and Salesforce archived the original JA3 repository and no longer maintains it. The name survives as shorthand for TLS client fingerprinting in general; TLS fingerprinting is the technique, and JA3 is one encoding of it. Hashes also move when libraries change. Python, Node and Chrome all offered group 4588 in field 4, which IANA lists as X25519MLKEM768, a post-quantum hybrid; curl 8.7.1 did not. A library upgrade that adds one group changes the hash without anything in your code changing.

A proxy cannot alter any of this. Through HTTP CONNECT or SOCKS the handshake runs end to end between your client and the target, and the proxy forwards bytes it cannot read. Changing JA3 means changing the TLS stack: a library built to reproduce a browser’s ClientHello, or a real browser. Even then the handshake is checked alongside HTTP/2 behaviour and header order, which our default request headers study found to be stable per client, and the AI agents guide works through what that means for a fetch layer.

Frequently asked questions

Why does my JA3 hash change on every connection?
If you are measuring a Chromium-based browser, the cause is extension-order shuffling: in our test twelve connections gave twelve hashes from one set of extensions. GREASE can do the same thing to a detector that forgets to strip it, since RFC 8701 values change between connections. Libraries such as curl, Python's urllib and Node's fetch gave one hash across repeated connections.
Can a proxy change my JA3 fingerprint?
No. Through HTTP CONNECT or SOCKS the TLS handshake runs end to end between your client and the target, and the proxy only forwards the encrypted bytes. Only a proxy that terminates TLS itself, intercepting and re-encrypting, presents a different ClientHello, and that is its own handshake rather than a disguised version of yours.
Is JA3 still used if the repository is archived?
Salesforce archived the JA3 repository on 1 May 2025 and says it is no longer maintained, but the method is simple to compute and still appears in logs and tools. Newer detectors tend to use JA4, which sorts the lists so that browser extension shuffling no longer changes the value, and combine it with HTTP-level signals.

Sources

  1. Salesforce JA3 repository: the field order, the GREASE rule and JA3S (archived, read-only)
  2. FoxIO JA4+: the successor that sorts ciphers and extensions
  3. RFC 9846: The Transport Layer Security (TLS) Protocol Version 1.3, obsoletes RFC 8446; legacy_version fixed at 0x0303
  4. RFC 8701: Applying GREASE to TLS Extensibility, the reserved values JA3 ignores
  5. IANA TLS parameters: supported groups registry, 4588 = X25519MLKEM768

All terms, A to Z