---
title: "Chromium varied all 12 captured handshakes. curl and Go stayed the same across 3 each."
url: https://proxy.wiki/research/tls-clienthello-fingerprints/
type: Research Report
author: "proxy.wiki editorial"
published: 2026-09-01
updated: 2026-10-21
site: proxy.wiki
topics: ["Anti-bot systems"]
data_status: measured
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"
method: https://proxy.wiki/research/tls-clienthello-fingerprints/#method
key_figure: "12 of 12 Chromium connections, each with a different extension order"
license: CC BY 4.0; quote freely with attribution to https://proxy.wiki/
---

# 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.

## Key takeaways

- 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.
- curl and Go sent an identical order on three connections each. The other five libraries were sampled once, so this study does not claim repeatability for them.
- Cipher count alone separates most clients: Go offers 13 suites, curl 49, Node 52, wget 68.
- None of the 7 library clients in the captured rows sent GREASE. Chromium sent it on all 12 connections, so its absence separates the observed browser from these captures.
- Node's global fetch and node:https differ by exactly one extension, ALPN, so the same runtime yields two distinguishable fingerprints.
- A tunnelling proxy changes none of this: the handshake is built by the client's TLS library and forwarded unchanged.

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](/glossary/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_

| 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](/glossary/ja3-fingerprint/), 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](/glossary/residential-proxy/) carries the same handshake as a datacenter one, and changing country, provider or [exit node](/glossary/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](/glossary/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](/research/default-request-headers/) covers the layer above this one, and [HTTP/2 fingerprinting](/glossary/http2-fingerprint/) 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](/guides/proxies-in-python-requests-httpx/) and [proxies in Node.js](/guides/proxies-in-nodejs/), 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](/guides/proxies-for-ai-agents/) 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](https://creativecommons.org/licenses/by/4.0/). Reuse them with a link to this page.

- [tls-clienthello-fingerprints.csv](/wp-content/uploads/pw-data/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](/wp-content/uploads/pw-data/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.

## Data

- [tls-clienthello-fingerprints.csv](https://proxy.wiki/wp-content/uploads/pw-data/tls-clienthello-fingerprints.csv) (CSV, 1.9 KB, 19 rows)
- [tls-clienthello-fingerprints.json](https://proxy.wiki/wp-content/uploads/pw-data/tls-clienthello-fingerprints.json) (JSON, 9.4 KB, 19 records)

Licensed CC BY 4.0. Cite <https://proxy.wiki/research/tls-clienthello-fingerprints/>.

## 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](https://www.rfc-editor.org/rfc/rfc8446.html)
2. [IANA: TLS ExtensionType Values registry](https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml)
3. [RFC 8701: GREASE for TLS](https://www.rfc-editor.org/rfc/rfc8701.html)
4. [RFC 7301: Application-Layer Protocol Negotiation](https://www.rfc-editor.org/rfc/rfc7301.html)
5. [RFC 6066: TLS extensions, including server_name and the bar on literal IP addresses](https://www.rfc-editor.org/rfc/rfc6066.html)
6. [Chrome Platform Status: TLS ClientHello extension permutation, enabled by default in Chrome 110](https://chromestatus.com/feature/5124606246518784)
7. [Salesforce JA3: the fingerprint definition and its field order](https://github.com/salesforce/ja3)
8. [FoxIO JA4 technical details: the sorted extension list](https://github.com/FoxIO-LLC/ja4/blob/main/technical_details/JA4.md)
9. [BoringSSL tls1.h: extension 17613 is application_settings](https://github.com/google/boringssl/blob/main/include/openssl/tls1.h)
