The finding
12 of 12Chromium connections, each with a different extension order
Recovered capture summary: Chromium sent a different extension order on all 12 connections we captured, producing 12 different JA3-style hashes from one browser. Ten browser order rows were retained; connections 11 and 12 were counted but their orders were not printed.
On this page 12 sections
- Method
- What each client declared
- Finding 1: the browser fingerprint is different on every connection
- Finding 2: curl and Go repeated their observed order
- Finding 3: the observed extension orders distinguish these clients
- What those extension numbers are
- Finding 4: GREASE separated the browser from the captured library rows
- Finding 5: ALPN says which HTTP version you are prepared to speak
- What this means for proxies
- Reproducing this
- Download the data
- Limits
The recovered capture summary reports that a Chromium browser sent a different TLS fingerprint on each of 12 connections: twelve extension orders and twelve JA3-style hashes. curl and Go, connected three times each, produced one order each; the other five libraries were sampled once.
That complicates the usual account of TLS fingerprinting. A handshake can separate clients before a single header arrives, but this sample’s repeatability result applies only to curl and Go; the Chromium runs varied.
Method
On 1 September 2026, between 20:19 and 20:21 UTC, on one Mac, a raw TCP listener on 127.0.0.1:8443 accepted each connection, read the first flight and parsed the ClientHello directly: legacy version, cipher suites, the extension list in the order sent, supported groups, signature algorithms, ALPN and supported versions. The handshake was never completed. It does not need to be, because the ClientHello is sent in the clear and the client has already declared everything by that point.
The sample was five HTTP libraries with one connection each, three connections each from curl and Go to test repeatability, and twelve connections from one Chromium browser. Every library made a plain HTTPS request to the IP address with certificate verification disabled and no other configuration. The browser was the Chromium engine built into a desktop app. Three days earlier, in our header study, the same app reported Chrome/148.0.7778.280 in its User-Agent, but a ClientHello carries no User-Agent, so the exact build on the day was not recorded.
GREASE values were filtered out of the cipher and extension lists before counting, since they are deliberate noise rather than capability. Whether a client sends them at all is reported separately, because that is itself a signal. The listener and the parser are printed at the end of this page.
What each client declared
| Client | Ciphers | Extensions | Supported groups | Sig algs | ALPN | GREASE |
|---|---|---|---|---|---|---|
| Chromium | 15 | 15 | not recorded | not recorded | h2, http/1.1 | yes |
| GNU wget | 68 | 11 | 8 | 26 | none | no |
Node 24 global fetch |
52 | 11 | 8 | 26 | http/1.1 | no |
Node 24 node:https |
52 | 10 | 8 | 26 | none | no |
| curl 8.7.1 | 49 | 6 | 4 | 11 | h2, http/1.1 | no |
| python-requests 2.32.3 | 38 | 4 | 3 | 13 | http/1.1 | no |
| python-urllib 3.9 | 38 | 4 | 3 | 13 | none | no |
Go 1.24 net/http |
13 | 9 | 5 | 12 | none | no |
The parser read the browser’s supported groups and signature algorithms on every connection, but those two counts were never printed, and the capture file no longer exists. They are marked as not recorded rather than left blank, because this study did capture them.
Cipher count alone separates most of the list. Go offers thirteen suites where wget offers sixty-eight; a server that sees thirteen has a very short list of candidates before it looks at anything else. The pairs it cannot split are python-requests and python-urllib at 38, and the two Node APIs at 52.
Finding 1: the browser fingerprint is different on every connection
The recovered capture summary covers twelve consecutive connections from the same Chromium browser, with no restart and no configuration change:
| Measure | Result across 12 connections |
|---|---|
| Distinct extension sets | 1 |
| Distinct extension orders | 12 |
| Distinct cipher lists | 1 |
| Distinct JA3-style hashes | 12 of 12 |
The same fifteen extensions, shuffled into a new order every time. This is deliberate. Chrome has permuted ClientHello extensions by default since version 110, and its Chrome Platform Status entry gives the reason as reducing “ecosystem brittleness”, meaning servers and middleboxes that come to depend on a fixed order. Making the browser harder to fingerprint is a side effect, not the stated aim.
It is a large side effect, because JA3, the fingerprint most often named in articles about bot detection, is built over the ordered list. Its definition joins the TLS version, ciphers, extensions, elliptic curves and point formats in the order sent, then takes an MD5. The recovered JA3-style summary, over ciphers, extensions and groups, reports twelve values for twelve connections, so a blocklist entry for any one of them would have matched none of the other eleven. JA4, a newer scheme, sorts the extension list before hashing, so a shuffled order does not change it.
Ten of the twelve orders were printed during the capture and are reproduced here. Connections 11 and 12 were counted in the totals above, but their orders were not printed before the capture file was lost.
| Connection | Extension order as sent |
|---|---|
| 1 | 5, 65037, 10, 43, 35, 65281, 23, 11, 18, 17613, 45, 27, 13, 51, 16 |
| 2 | 51, 13, 65037, 45, 27, 23, 11, 5, 35, 18, 10, 65281, 43, 17613, 16 |
| 3 | 13, 45, 10, 17613, 11, 51, 16, 27, 65281, 18, 35, 5, 43, 23, 65037 |
| 4 | 51, 65281, 45, 17613, 35, 13, 27, 43, 18, 5, 16, 23, 11, 65037, 10 |
| 5 | 18, 10, 35, 45, 11, 16, 13, 65037, 23, 27, 51, 65281, 43, 17613, 5 |
| 6 | 17613, 18, 27, 43, 45, 65037, 5, 65281, 35, 51, 23, 11, 13, 10, 16 |
| 7 | 17613, 35, 45, 11, 51, 18, 23, 27, 65037, 16, 65281, 10, 5, 43, 13 |
| 8 | 17613, 13, 65281, 43, 5, 35, 51, 10, 23, 16, 45, 18, 27, 11, 65037 |
| 9 | 17613, 5, 43, 16, 51, 11, 13, 27, 65037, 65281, 18, 45, 35, 10, 23 |
| 10 | 65037, 51, 11, 16, 23, 35, 27, 18, 65281, 10, 13, 5, 45, 17613, 43 |
Finding 2: curl and Go repeated their observed order
The repeatability check covered only the two clients with extra connections:
curl, 3 consecutive connections -> 1 distinct extension order
Go, 3 consecutive connections -> 1 distinct extension order
Across the repeated captures, curl and Go kept one order across three connections each. The other five libraries were sampled once, so their rows show observed handshakes rather than a repeatability result. The recovered browser summary reports twelve orders across its twelve connections. The technique used to separate bots from browsers still has a measurable signal in this sample, but its repeatability differs by client.
For anyone writing a scraper, the practical reading is that a stable handshake can be a liability. curl and Go were identical across their repeated captures, while this browser varied across twelve connections.
Finding 3: the observed extension orders distinguish these clients
The extension identifiers below are the observed order for each library client. No two captured rows repeat another.
| Client | Extension order |
|---|---|
| curl 8.7.1 | 43, 51, 11, 10, 13, 16 |
| python-requests | 11, 10, 13, 16 |
| python-urllib | 11, 10, 35, 13 |
| GNU wget | 65281, 11, 10, 35, 22, 23, 49, 13, 43, 45, 51 |
Node fetch |
65281, 11, 10, 35, 16, 22, 23, 13, 43, 45, 51 |
Node node:https |
65281, 11, 10, 35, 22, 23, 13, 43, 45, 51 |
| Go 1.24 | 11, 65281, 23, 18, 5, 10, 13, 43, 51 |
Two details are worth drawing out. Node’s fetch and node:https differ by exactly one extension, 16, which is ALPN, so the same runtime produces two distinguishable fingerprints depending on which API you call. And curl is the only library that does not open with 11 or 65281: it leads with 43, supported_versions. Go is the only library that sends 5 (status_request) and 18 (signed_certificate_timestamp), two extensions that every browser capture also carried.
What those extension numbers are
The identifiers above are IANA-registered TLS ExtensionType values. Names here are taken from the registry rather than from memory, because several were renamed and the old names are still widely repeated.
| ID | Registered name | What its presence tells a server |
|---|---|---|
| 0 | server_name |
SNI: the hostname, in the clear, before encryption |
| 5 | status_request |
The client will accept a stapled OCSP response |
| 10 | supported_groups |
Which key-exchange groups; the count varies widely by library |
| 11 | ec_point_formats |
Legacy, but all seven captured library rows and the browser captures include it |
| 13 | signature_algorithms |
Another list whose length is distinctive |
| 16 | application_layer_protocol_negotiation |
ALPN: whether HTTP/2 is on the table |
| 18 | signed_certificate_timestamp |
Certificate Transparency; sent by the browser and by Go only |
| 22 | encrypt_then_mac |
Sent by wget and both Node APIs |
| 23 | extended_main_secret |
Renamed from extended_master_secret |
| 27 | compress_certificate |
Certificate compression; in the browser captures only |
| 35 | session_ticket |
Session resumption support |
| 43 | supported_versions |
Where TLS 1.3 is actually negotiated |
| 45 | psk_key_exchange_modes |
Paired with 1.3 resumption |
| 49 | post_handshake_auth |
Sent by wget only |
| 51 | key_share |
The 1.3 key exchange |
| 65037 | encrypted_client_hello |
ECH. Present in the browser captures, absent from all seven captured library rows |
| 65281 | renegotiation_info |
Legacy renegotiation marker |
Two of these separate the browser from every captured library row on their own. 65037, encrypted client hello, appeared in every browser capture and in none of the seven captured library rows. 17613 is not in the registry at all: the registry lists 14907 to 19017 as unassigned. BoringSSL, the TLS library in Chrome and Chromium, defines it as TLSEXT_TYPE_application_settings, and its presence is close to a browser signature by itself.
The absence of 0 in our captures is an artefact of the test. We connected to an IP address, and RFC 6066 does not permit a literal IP address in server_name, so no client sent one. Given a hostname, the name travels in this extension in the clear unless encrypted client hello is in use, which is why a proxy usually sees the destination hostname even when it cannot read the request.
Finding 4: GREASE separated the browser from the captured library rows
GREASE is the practice of inserting deliberately invalid values into the cipher and extension lists, so that servers which cannot tolerate unknown values break early and visibly rather than years later. Chromium sent it on all twelve connections. None of the seven library clients in the captured rows sent it. The five one-shot library rows do not establish what they would do on a repeat.
That makes its absence a useful observed separator in this sample: no GREASE in the captured library rows, GREASE in every Chromium connection. It cannot be forged by setting a header, and it is not affected by which proxy carries the connection.
Finding 5: ALPN says which HTTP version you are prepared to speak
Only curl and the browser offered h2. Node’s fetch and python-requests offered http/1.1 only. wget, node:https, python-urllib and Go offered no ALPN at all.
A client that advertises no ALPN is telling the server it will not negotiate HTTP/2 in the handshake. The browser offered h2, so its absence is another cheap separator, and unlike header order it is decided by the TLS library rather than by anything the request layer can override.
What this means for proxies
Everything above is produced by the client’s TLS library before any header is sent. A proxy that tunnels HTTPS with CONNECT forwards those bytes unchanged, so a residential address carries the same handshake as a datacenter one, and changing country, provider or exit node changes none of it. The exception is a proxy that terminates TLS itself, which replaces your handshake with its own; see TLS interception.
That is the practical answer to a question we see constantly: why a scraper with perfect headers, on a clean residential address, still gets refused. The classification can finish before the headers arrive. Our companion study on what HTTP clients send by default covers the layer above this one, and HTTP/2 fingerprinting covers the frames that follow the handshake.
Only two things change a TLS fingerprint: replacing the TLS implementation with one that reproduces a browser’s handshake, or driving a real browser engine. Configuration at the HTTP layer cannot reach it. The proxy settings for the libraries above are in our guides to proxies in Python and proxies in Node.js, and none of those settings alters a single byte of the handshake. For agents that browse on someone’s behalf, proxies for AI agents that browse applies these results to that case.
Reproducing this
The listener parses the ClientHello without completing the handshake and prints one line per connection:
import socket, struct, json
GREASE = {0x0a0a,0x1a1a,0x2a2a,0x3a3a,0x4a4a,0x5a5a,0x6a6a,0x7a7a,
0x8a8a,0x9a9a,0xaaaa,0xbaba,0xcaca,0xdada,0xeaea,0xfafa}
u16 = lambda b, i: struct.unpack_from('!H', b, i)[0]
def parse(d):
if len(d) < 6 or d[0] != 0x16 or d[5] != 0x01:
return None # not a ClientHello
i = 9 + 2 + 32 # header, version, random
i += 1 + d[i] # session id
n = u16(d, i); i += 2
ciphers = [u16(d, i + k) for k in range(0, n, 2)]
i += n
i += 1 + d[i] # compression methods
exts, total = [], u16(d, i); i += 2
end = i + total
while i + 4 <= end:
t, ln = u16(d, i), u16(d, i + 2)
i += 4 + ln
if t not in GREASE:
exts.append(t)
return {'ciphers': len([c for c in ciphers if c not in GREASE]),
'extensions': exts,
'grease': any(c in GREASE for c in ciphers)}
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(('127.0.0.1', 8443))
s.listen(8)
while True:
c, _ = s.accept()
print(json.dumps(parse(c.recv(16384))), flush=True)
c.close()
Run under Python 3.9.6 on 21 October 2026 and pointed at by curl -sk https://127.0.0.1:8443/ and then by one python-requests call, it printed these two lines, matching the curl and python-requests rows above:
{"ciphers": 49, "extensions": [43, 51, 11, 10, 13, 16], "grease": false}
{"ciphers": 38, "extensions": [11, 10, 13, 16], "grease": false}
Point any client at it and read what it wrote. To reproduce the randomisation result, connect from the same browser a dozen times and compare the extension order, not the extension set.
Download the data
The captures are published as files under CC BY 4.0. Reuse them with a link to this page.
- tls-clienthello-fingerprints.csv: 19 recovered rows: the seven one-shot library rows and the twelve Chromium rows, with cipher, extension, group and signature-algorithm counts, ALPN, GREASE, the highest supported version and the retained extension orders. Chromium connections 11 and 12 have null extension-order and ALPN fields because those values were counted but not printed.
- tls-clienthello-fingerprints.json: the same rows, plus the repeat-run results for curl and Go, the method and the list of known gaps.
An empty cell means the value was captured but not kept. In the browser rows, supported groups and signature algorithms are empty on every connection, and extension order and ALPN are empty for connections 11 and 12.
Limits
- One machine, one date. Measured on macOS. The curl here is Apple’s build:
curl -Vreportslibcurl/8.7.1 (SecureTransport) LibreSSL/3.3.6. A curl built against another TLS library may offer a different cipher list, so the curl row describes this build rather than curl in general. - One browser. The browser row is one Chromium build. Firefox and Safari send different sets, and this study does not measure them.
- Randomisation observed, not proven universal. The recovered summary reports twelve orders in twelve connections, which matches Chrome’s documented permutation. It is not proof that every Chromium build or every embedder behaves the same way.
- Values captured but not kept. The browser’s supported-group and signature-algorithm counts, and two of its twelve extension orders, were parsed but never printed, and the capture file no longer exists. They are marked as not recorded rather than estimated.
- No claim about detection. This measures what clients emit. What any given server does with it is outside what a listener can observe.
Download the data
The raw results behind this study, as files. Reuse them under CC BY 4.0 with a link to this page.
Frequently asked questions
Does a TLS fingerprint identify my browser?
Is JA3 still useful?
Why does my scraper get blocked when its headers are perfect?
Will a better proxy fix a TLS fingerprint?
What is GREASE and why does it matter?
Which library is closest to a browser?
Can I download the captures?
Sources
- RFC 8446: TLS 1.3, the ClientHello message
- IANA: TLS ExtensionType Values registry
- RFC 8701: GREASE for TLS
- RFC 7301: Application-Layer Protocol Negotiation
- RFC 6066: TLS extensions, including server_name and the bar on literal IP addresses
- Chrome Platform Status: TLS ClientHello extension permutation, enabled by default in Chrome 110
- Salesforce JA3: the fingerprint definition and its field order
- FoxIO JA4 technical details: the sorted extension list
- BoringSSL tls1.h: extension 17613 is application_settings