---
title: "What is HTTP\/2 fingerprinting?"
url: https://proxy.wiki/glossary/http2-fingerprint/
type: Glossary Term
author: "proxy.wiki editorial"
published: 2026-09-06
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 HTTP/2 fingerprinting?

> An HTTP/2 fingerprint identifies a client from the settings, window size and pseudo-header order it uses to open a connection, not from header values.

Editing headers does not change it. Every value it is built from sits in frames the HTTP/2 library writes before your first header goes out, and the same frames govern every request on that connection. A client that copies a browser’s user agent but keeps its own library’s frames has made the disguise easier to spot, not harder.

## What the client sends first

RFC 9113 requires the 24-octet connection preface to be followed by a SETTINGS frame. Three of the four clients below then sent a WINDOW_UPDATE, and all four followed with the HEADERS frame of their first request. RFC 9113 fixes the layout: a 9-octet frame header, then one 6-octet entry per setting, made of a 16-bit identifier and a 32-bit value. Which settings appear, with what values and in what order, is left to the implementation. This is the SETTINGS frame Chrome 155 sent to our test server, byte for byte:

```
00 00 18 04 00 00 00 00 00   length 24, type 0x4 SETTINGS, flags 0, stream 0
00 01 00 01 00 00            0x1 HEADER_TABLE_SIZE     65536
00 02 00 00 00 00            0x2 ENABLE_PUSH           0
00 04 00 60 00 00            0x4 INITIAL_WINDOW_SIZE   6291456
00 06 00 04 00 00            0x6 MAX_HEADER_LIST_SIZE  262144
```

A setting the client leaves out takes its default from RFC 9113, such as 65,535 octets for the initial stream window and 16,384 for the largest frame. Leaving something out is therefore as informative as sending it.

Akamai’s 2017 white paper on passive HTTP/2 fingerprinting proposed a compact notation for all this: the settings in the order sent, the WINDOW_UPDATE increment, any PRIORITY frames, then the order of the four pseudo-headers, written `S[;]|WU|P[,]#|PS[,]`. The pseudo-headers are abbreviated m, a, s and p for `:method`, `:authority`, `:scheme` and `:path`.

## Four clients, captured

On 21 October 2026 we ran a local TLS server on macOS that offered only `h2` in ALPN, recorded the first frames of each connection and decoded them. Each client connected two or three times, and repeated runs of the same code produced the same values.

| Client | SETTINGS, in the order sent | WINDOW_UPDATE | Pseudo-header order |
| --- | --- | --- | --- |
| Chrome 155.0.8059.85, headless | 1:65536;2:0;4:6291456;6:262144 | 15663105 | m,a,s,p |
| curl 8.7.1 (nghttp2 1.68.1) | 3:100;4:10485760;2:0 | 1048510465 | m,s,a,p |
| Go 1.24.4 net/http | 2:0;4:4194304;5:16384;6:10485760 | 1073741824 | a,m,p,s |
| Node 24.2.0 node:http2 | None: an empty SETTINGS frame | None sent | Whatever order the calling code used |

Chrome’s window increment, 15663105, is the number Akamai’s paper recorded for Chrome 58 in 2017. Its settings have moved since: the paper lists `1:65536;3:1000;4:6291456`, and Chrome 155 has dropped the concurrency setting and added `ENABLE_PUSH` and `MAX_HEADER_LIST_SIZE`. Chrome was also the only client to carry priority information inside its HEADERS frame, an exclusive dependency with weight 256.

Node was the odd one. It sent nothing beyond an empty SETTINGS frame, which RFC 9113 permits, and its pseudo-headers followed the object passed to `request()`. Reordering that object reordered the frame.

## Where it catches impersonation

A scraper that sends Chrome’s user agent, and even Chrome’s TLS handshake, then drives the connection with a general-purpose library presents a browser at one layer and curl or Go at the next. That contradiction is a stronger signal than either half. The TLS side of the problem is measured in [our ClientHello study](/research/tls-clienthello-fingerprints/), which also found that [ALPN decides whether HTTP/2 happens at all](/research/tls-clienthello-fingerprints/#finding-5-alpn-says-which-http-version-you-are-prepared-to-speak): Node’s fetch and python-requests offered only HTTP/1.1. Those clients never show an HTTP/2 fingerprint, but a Chrome user agent arriving over HTTP/1.1 is its own oddity. On HTTP/1.1 the comparable signal is header order, covered in [what HTTP clients send before you configure anything](/research/default-request-headers/).

A proxy does not help. An [HTTP CONNECT](/glossary/http-connect/) or SOCKS proxy relays encrypted bytes, so the target reads your client’s frames whichever exit you use. Only a middlebox performing [TLS interception](/glossary/tls-interception/) replaces them, and it replaces your [TLS fingerprint](/glossary/ja3-fingerprint/) along with them. The workable options are the ones listed under [making curl look less like curl](/guides/how-to-use-a-proxy-with-curl/#making-curl-look-less-like-curl): a client built to imitate a browser at every layer, or the browser itself.

## Capturing your own client

This prints the SETTINGS and WINDOW_UPDATE values of whatever connects to it. It ran on Python 3.15.0 against curl 8.7.1 and Chrome 155.

```
# openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -nodes \
#   -keyout key.pem -out cert.pem -days 2 -subj /CN=localhost
import socket, ssl, struct

ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
ctx.load_cert_chain("cert.pem", "key.pem")
ctx.set_alpn_protocols(["h2"])
srv = socket.create_server(("127.0.0.1", 8443))
conn = ctx.wrap_socket(srv.accept()[0], server_side=True)
conn.sendall(b"\x00\x00\x00\x04\x00\x00\x00\x00\x00")   # our own empty SETTINGS
conn.settimeout(2)
data = b""
try:
    while chunk := conn.recv(4096):
        data += chunk
except TimeoutError:
    pass
i, out = 24, []                                          # skip the 24-octet preface
while i + 9 <= len(data):
    length, ftype = int.from_bytes(data[i:i+3], "big"), data[i+3]
    body = data[i+9:i+9+length]
    if ftype == 4:
        out.append(";".join("%d:%d" % struct.unpack(">HI", body[k:k+6]) for k in range(0, length, 6)))
    elif ftype == 8:
        out.append(str(struct.unpack(">I", body[:4])[0] & 0x7FFFFFFF))
    elif ftype == 1:
        break
    i += 9 + length
print("|".join(out))
```

```
$ python3 h2settings.py &
$ curl -sk --http2 https://localhost:8443/ -o /dev/null
3:100;4:10485760;2:0|1048510465
```

## Frequently asked questions

### Does a proxy change my HTTP/2 fingerprint?

Not a CONNECT or SOCKS proxy. The frames travel inside the TLS session, so the proxy never sees them and the target reads your client's values. A proxy that terminates TLS does replace them, along with your TLS fingerprint. In our test Squid's ssl-bump offered no ALPN at all, which leaves the server only HTTP/1.1.

### Does forcing HTTP/1.1 avoid the problem?

It removes this signal and creates another. Chrome offered h2 on every connection we captured, so a client that claims to be Chrome and negotiates only HTTP/1.1 stands out, and HTTP/1.1 header order is a fingerprint of its own.

## Sources

1. [RFC 9113: HTTP/2, frame format, SETTINGS parameters and their initial values](https://www.rfc-editor.org/rfc/rfc9113.html)
2. [IANA: HTTP/2 settings registry](https://www.iana.org/assignments/http2-parameters/http2-parameters.xhtml)
3. [Akamai white paper: Passive Fingerprinting of HTTP/2 Clients (Black Hat Europe 2017), source of the S[;]|WU|P[,]#|PS[,] format and the Chrome 58 values](https://www.blackhat.com/docs/eu-17/materials/eu-17-Shuster-Passive-Fingerprinting-Of-HTTP2-Clients-wp.pdf)
