---
title: "What is TLS fingerprinting?"
url: https://proxy.wiki/glossary/tls-fingerprinting/
type: Glossary Term
author: "proxy.wiki editorial"
published: 2026-08-19
updated: 2026-10-21
site: proxy.wiki
topics: ["Anti-bot systems"]
license: CC BY 4.0; quote freely with attribution to https://proxy.wiki/
---

# What is TLS fingerprinting?

> Identifying the software behind a connection from its TLS ClientHello, which is sent in the clear before any HTTP header.

The ClientHello is written by the TLS library, not by your code, so it identifies the library whatever your headers say. A CONNECT proxy relays it byte for byte; only a proxy that performs [TLS interception](/glossary/tls-interception/) replaces it with its own. The full measurement, seven HTTP libraries and a browser captured at the byte level, is the proxy.wiki study [Chromium varied all 12 captured handshakes. curl and Go stayed the same across 3 each.](/research/tls-clienthello-fingerprints/) This entry shows what the message looks like and what a server reads from it.

## What the server receives

This is the first record curl 8.7.1 sent to a raw TCP listener on our machine, annotated. Offsets are hexadecimal. None of it is encrypted, because encryption has not started yet.

```
offset  bytes                       field
0000    16                          record type 0x16, handshake
0001    03 01                       record version (legacy)
0003    01 28                       record length 296
0005    01                          handshake type 0x01, ClientHello
0006    00 01 24                    handshake length 292
0009    03 03                       legacy_version
000b    60 54 c2 b3 3c 99 65 0c ... random, 32 bytes
002b    20 94 4b 8e 5f 0a 27 0e ... session id, 32 bytes
004c    00 62 13 03 13 02 13 01 ... cipher suites, 98 bytes = 49 suites
00b0    01 00                       compression methods: null only
00b2    00 79                       extensions, 121 bytes in total
00b4    00 2b ...                   43  supported_versions
00c1    00 33 ...                   51  key_share, one X25519 key
00eb    00 0b ...                   11  ec_point_formats
00f1    00 0a ...                   10  supported_groups
00ff    00 0d ...                   13  signature_algorithms
011b    00 10 ...                   16  application_layer_protocol_negotiation
```

The random value and session id change on every connection and carry no identity. Everything else is the library’s fixed choice: which cipher suites it offers and in what order, which extensions, which groups and signature algorithms. A fingerprint is built from those. JA3, the best-known scheme, joins the TLS version, ciphers, extensions, elliptic curves and point formats as decimal lists and takes an MD5 hash of the result. JA4 sorts the cipher and extension lists before hashing, so a reordered list still gives the same value.

There is no `server_name` extension in this capture, and that is correct. The target was an IP address, and RFC 6066 does not allow a literal IP in that field. Against a hostname it would be there, in the clear, naming the site you are about to visit.

## Library against browser

The same listener captured two connections from headless Chrome 155, a few seconds apart:

| Field | curl 8.7.1, both captures | Chrome 155, two connections |
| --- | --- | --- |
| ClientHello size | 301 bytes | 1,899 and 1,963 bytes |
| Cipher suites | 49 | 15, plus one GREASE value |
| Extensions | 6 | 16, plus two GREASE values |
| Extension order | 43, 51, 11, 10, 13, 16 in both captures | Different on each connection |
| Key share | One 32-byte X25519 key | X25519MLKEM768 with a 1,216-byte key, plus X25519 |
| Unregistered extension numbers | None | 17613 and 51764 |

The browser is the one that varies in this comparison. Chrome shuffles its extension order on every connection, so a hash over the order as sent, like the original JA3, gives a new value each time; sorting first, as JA4 does, removes that. The sampled curl client kept the identical structure in both captures, which made it easy to recognise while the browser was hard to pin to a single hash.

Two of Chrome’s extension numbers, 17613 and 51764, do not appear in the IANA TLS ExtensionType registry. GREASE values, defined in RFC 8701, are deliberate dummies that browsers insert so servers keep tolerating values they do not recognise. Their absence is a quick sign that a client is not a mainstream browser.

## What changes it, and what does not

Headers, the [user agent](/glossary/user-agent/), the proxy, the country and the exit address all leave the ClientHello untouched. Only changing the TLS implementation changes it: a library built to replay a browser’s handshake, or a real browser engine. Even then the rest of the request has to agree. A browser handshake followed by curl’s three default headers is its own contradiction, measured in [What HTTP clients send before you configure anything](/research/default-request-headers/). For Python clients the options are set out in [Using proxies in Python](/guides/proxies-in-python-requests-httpx/), and for agents in [Proxies for AI agents that browse](/guides/proxies-for-ai-agents/).

## Seeing your own

No packet capture is needed. A listener that reads the first record is enough, because the ClientHello arrives before the handshake can fail:

```
# terminal 1, Python 3.9 or later
python3 -c "import socket;s=socket.create_server(('127.0.0.1',8443));c,_=s.accept();d=c.recv(65536);print(len(d),'bytes',d[:6].hex(' '))"

# terminal 2
curl -sk https://127.0.0.1:8443/

# terminal 1 prints
301 bytes 16 03 01 01 28 01
```

The full parser that produced the annotated layout above is printed at the end of the [study](/research/tls-clienthello-fingerprints/).

**How this was captured.** 21 October 2026, macOS, curl 8.7.1 and Chrome 155.0.8059.85 in headless mode with a fresh profile, each pointed at a raw TCP listener on 127.0.0.1 that read the first TLS record and closed the connection. Two connections from each client. Extension names are from the IANA registry as updated on 8 October 2026.

## Frequently asked questions

### Does a proxy change my TLS fingerprint?

No. A CONNECT proxy relays the encrypted stream without touching it, so the ClientHello the site receives is the one your TLS library wrote, through any proxy and from any country.

### Why does Chrome produce a different JA3 hash on every connection?

Chrome shuffles the order of its TLS extensions on each connection, and the original JA3 hashes that order as sent. Two captures from Chrome 155 had two different orders. JA4 sorts the extensions before hashing, so the shuffle no longer changes the value.

### What is GREASE in a ClientHello?

Reserved dummy values, defined in RFC 8701, that browsers insert into their cipher, extension and group lists so servers keep tolerating values they do not recognise. Chrome 155 sent them and curl 8.7.1 did not, so their absence is a quick sign of a non-browser client.

## Sources

1. [RFC 8446: TLS 1.3, the ClientHello](https://www.rfc-editor.org/rfc/rfc8446.html#section-4.1.2)
2. [RFC 8701: Applying GREASE to TLS extensibility](https://www.rfc-editor.org/rfc/rfc8701.html)
3. [RFC 6066: Server Name Indication, literal IP addresses not permitted](https://www.rfc-editor.org/rfc/rfc6066.html#section-3)
4. [IANA: TLS ExtensionType Values registry](https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml)
5. [Salesforce: JA3 method and reference implementation](https://github.com/salesforce/ja3)
6. [FoxIO: JA4 technical details](https://github.com/FoxIO-LLC/ja4/blob/main/technical_details/JA4.md)
