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?
Can a proxy change my JA3 fingerprint?
Is JA3 still used if the repository is archived?
Sources
- Salesforce JA3 repository: the field order, the GREASE rule and JA3S (archived, read-only)
- FoxIO JA4+: the successor that sorts ciphers and extensions
- RFC 9846: The Transport Layer Security (TLS) Protocol Version 1.3, obsoletes RFC 8446; legacy_version fixed at 0x0303
- RFC 8701: Applying GREASE to TLS Extensibility, the reserved values JA3 ignores
- IANA TLS parameters: supported groups registry, 4588 = X25519MLKEM768