Skip to content
Anti-bot systems

Chromium varied all 12 captured handshakes. curl and Go stayed the same across 3 each.

Chromium produced 12 different JA3-style hashes in 12 connections. curl and Go kept one order across 3 each; five other libraries were sampled once.

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.

Measured by us Sample 7 HTTP libraries (five sampled once; curl and Go sampled 3 times each) and one Chromium browser on 2026-09-01; 12 browser connections How it was measured Download the data CSV, JSON

On this page 12 sections
  1. Method
  2. What each client declared
  3. Finding 1: the browser fingerprint is different on every connection
  4. Finding 2: curl and Go repeated their observed order
  5. Finding 3: the observed extension orders distinguish these clients
  6. What those extension numbers are
  7. Finding 4: GREASE separated the browser from the captured library rows
  8. Finding 5: ALPN says which HTTP version you are prepared to speak
  9. What this means for proxies
  10. Reproducing this
  11. Download the data
  12. 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

Cipher suites and extensions offered in one ClientHello, GREASE removed Drawn from the table below.
Cipher suites and extensions offered in one ClientHello, GREASE removed. Bar chart of Ciphers, Extensions by Client.8 rows, drawn from the table that follows this chart.ChromiumChromium · Ciphers: 1515Chromium · Extensions: 1515GNU wgetGNU wget · Ciphers: 6868GNU wget · Extensions: 1111Node 24 global fetchNode 24 global fetch · Ciphers: 5252Node 24 global fetch · Extensions: 1111Node 24 node:httpsNode 24 node:https · Ciphers: 5252Node 24 node:https · Extensions: 1010curl 8.7.1curl 8.7.1 · Ciphers: 4949curl 8.7.1 · Extensions: 66python-requests 2.32.3python-requests 2.32.3 · Ciphers: 3838python-requests 2.32.3 · Extensions: 44python-urllib 3.9python-urllib 3.9 · Ciphers: 3838python-urllib 3.9 · Extensions: 44Go 1.24 net/httpGo 1.24 net/http · Ciphers: 1313Go 1.24 net/http · Extensions: 99010203040506070Cipher suites and extensions offered in one ClientHello, GREASE removed. Bar chart of Ciphers, Extensions by Client.8 rows, drawn from the table that follows this chart.ChromiumChromium · Ciphers: 1515Chromium · Extensions: 1515GNU wgetGNU wget · Ciphers: 6868GNU wget · Extensions: 1111Node 24 global fetchNode 24 global fetch · Ciphers: 5252Node 24 global fetch · Extensions: 1111Node 24 node:httpsNode 24 node:https · Ciphers: 5252Node 24 node:https · Extensions: 1010curl 8.7.1curl 8.7.1 · Ciphers: 4949curl 8.7.1 · Extensions: 66python-requests 2.32.3python-requests 2.32.3 · Ciphers: 3838python-requests 2.32.3 · Extensions: 44python-urllib 3.9python-urllib 3.9 · Ciphers: 3838python-urllib 3.9 · Extensions: 44Go 1.24 net/httpGo 1.24 net/http · Ciphers: 1313Go 1.24 net/http · Extensions: 990255075
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 -V reports libcurl/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?
Less than it used to. The recovered capture summary covers twelve consecutive connections from one Chromium browser and reports twelve different extension orders, and therefore twelve different JA3-style hashes. Ten browser order rows were retained; connections 11 and 12 were counted but their orders were not printed. The extension set was identical each time; only the order changed. Chrome has permuted the order by default since version 110 to keep servers from depending on it, and a hash over the ordered list stops working as an identifier as a side effect.
Is JA3 still useful?
For curl and Go, yes in this sample: each kept one extension order across three connections. The other five libraries were sampled once, so their rows show observed handshakes, not repeatability. For Chrome, a JA3 value matched one of our twelve connections and none of the others, because the hash is taken over the ordered extension list. JA4, a newer scheme, sorts the extensions before hashing, so the shuffle does not change it.
Why does my scraper get blocked when its headers are perfect?
Because the TLS handshake is sent before any header, and it is produced by your TLS library rather than by your code. In this capture each library row had a distinctive handshake: Go offered 13 cipher suites, curl 49, wget 68. The repeated curl and Go runs kept their order, while the other five libraries were sampled once. The classification can finish before a single header arrives.
Will a better proxy fix a TLS fingerprint?
No. Through a CONNECT tunnel the handshake is generated by the client and forwarded unchanged, so it is identical through any such proxy, from any country, on any category of address. A proxy that terminates TLS replaces it with its own handshake, which is the proxy's fingerprint instead. Only replacing the TLS implementation or driving a real browser engine changes yours.
What is GREASE and why does it matter?
GREASE inserts deliberately invalid values into the cipher and extension lists so that servers which cannot tolerate unknown values fail early and visibly. Chromium sent it on every connection. None of the seven library clients in the captured rows did. That makes its absence a cheap single-bit signal that cannot be forged at the header layer.
Which library is closest to a browser?
No captured library row matched the browser on this measure. wget and Node's global fetch sent the most extensions of the libraries, eleven each, against the browser's fifteen, and both lacked encrypted client hello (65037) and the application-settings extension (17613) that every browser capture carried. Closeness on count does not help when specific extensions are absent.
Can I download the captures?
Yes. Every connection is published as CSV and JSON under CC BY 4.0, linked from the Download the data section of the study. The browser's supported-group and signature-algorithm counts, and two of its twelve extension orders, were captured but not kept, and are empty in the files.

Sources

  1. RFC 8446: TLS 1.3, the ClientHello message
  2. IANA: TLS ExtensionType Values registry
  3. RFC 8701: GREASE for TLS
  4. RFC 7301: Application-Layer Protocol Negotiation
  5. RFC 6066: TLS extensions, including server_name and the bar on literal IP addresses
  6. Chrome Platform Status: TLS ClientHello extension permutation, enabled by default in Chrome 110
  7. Salesforce JA3: the fingerprint definition and its field order
  8. FoxIO JA4 technical details: the sorted extension list
  9. BoringSSL tls1.h: extension 17613 is application_settings

Read this page as Markdown · Quote it freely under CC BY 4.0 with a link back.