Skip to content

Fingerprints

zhttp sends each server the same TLS ClientHello your app sent, so the server sees the app’s JA3 and JA4, not zhttp’s. HTTP/2 settings and header order go through unchanged too. The TLS tab and the tls.peet.ws check show whether that worked for a given request. The TCP connection underneath is your computer’s own, unless you set it to look like your device’s.

Select a request and open TLS in the inspector.

Fingerprint compares the two handshakes:

Field Shows
Hello sent to server The verdict, below
JA4, JA3 and PeetPrint at server What the server received
JA4, JA3 and PeetPrint from client What your app sent
Note, Difference Anything that changed, one line each
Verdict Means
Identical to the client’s The same, apart from the random values every connection has
Same shape as the client’s Your app resumed an earlier session. The server got zhttp’s own ticket from that server instead of your app’s, or none if zhttp holds none. Everything else is the same. The Note lines say which.
Differs from the client’s Some fields differ. The Difference lines list them.
Not the client’s hello zhttp couldn’t reproduce this hello, so the server got a generic one

The tab also lists your app’s ClientHello field by field, what the server negotiated (version, cipher suite, key exchange, ALPN, handshake time) and the HTTP/2 fingerprint.

PeetPrint is tls.peet.ws’s own TLS fingerprint. zhttp works it out the same way, so it matches what the check reports.

When a handshake fails, the tab says which side failed and why: Client rejected the proxy or Server handshake failed, with a Likely cause line. See Troubleshooting.

Right-click a request › Fingerprint at tls.peet.ws. zhttp sends a GET to https://tls.peet.ws/api/all on a connection made the way your app made this request’s, with the request’s headers in their order, and shows the report tls.peet.ws sends back. Esc closes it.

Before it goes, zhttp removes anything that could carry a credential or say where the request was going:

  • headers whose names contain cookie, auth, token, session, secret, key, csrf, xsrf, signature, password or jwt;
  • headers whose values start with Bearer or Basic;
  • Referer, Origin and the body’s headers.

Right-click a request › Export TLS profile › a format, and choose where to save it. The profile makes another HTTP library connect the way your app did: the same ClientHello, HTTP/2 SETTINGS, WINDOW_UPDATE, PRIORITY frames and pseudo-header order, and the same header order.

Format Saved as Use it with
tls-client (Go) .go tls-client in Go: tls_client.NewHttpClient(logger, <Name>Options...)
tls-client (JSON) .tls-client.json tls-client’s Python, Node or C# bindings: merge its fields into the request
httpcloak (JSON) .httpcloak.json httpcloak: fingerprint.LoadAndBuildPreset, or load_preset_from_json in its bindings

The Go file declares three variables: the client options, the ClientProfile and the default headers. The httpcloak preset carries your app’s own ClientHello bytes (raw_client_hello), which httpcloak fills with fresh random values on every connection.

The profile keeps every header’s position, and the values of User-Agent, Accept*, Sec-CH-* and X-* headers. Cookies, credentials, Content-* and Host belong to each request, so your code sends them.

If zhttp saw the same client send its extensions in another order on another connection, the profile turns on the library’s extension shuffling, as Chrome shuffles them on every handshake.

When a format can’t represent the client

Section titled “When a format can’t represent the client”

Export stops and names the field. The common cases:

Format Can’t send
All A ClientHello split across TLS records, a session ID that isn’t 32 bytes, a record marked TLS 1.2, or no connection WINDOW_UPDATE
tls-client Padding or GREASE extensions other than BoringSSL’s
tls-client (JSON) Extensions it has no field for, such as signature_algorithms_cert (Go clients send it), PSK modes other than psk_dhe_ke, and key share groups it has no name for
httpcloak PRIORITY frames, a first request on a stream other than 1, a resumed session, and HTTP/2 settings other than 1–6 and 9

Export a request that went over HTTP/2 when your app offers it. A connection that used HTTP/1.1 says nothing about the app’s HTTP/2 fingerprint.

AI agents export profiles with zhttp_export_profile. See AI agents.

Your app’s TLS and HTTP/2 reach the server as your app sent them, but the TCP connection they travel in is opened by your computer. A server can tell a phone’s connections from a computer’s by a few of their values, so an iPhone’s TLS arriving over a Windows computer’s connection doesn’t look like an iPhone.

TCP, at the right end of the session’s tab row, sets those values for the session’s connections.

  1. Click TCP and switch it on.
  2. Pick the device you’re capturing under Profile, or type your own values.
Profile TTL Window scale Timestamps
iPhone 64 6 On
Mac 64 6 On
Windows 128 8 Off
Linux 64 7 On

The values apply to the connections the session makes from then on. The tab row shows the profile, for example TCP iPhone, or Custom once you change a value. Switch it off to go back to your computer’s own connections.

Android has no profile: its window scale differs from one phone to the next. Type your phone’s values instead.

On a Mac, connections already look much like an iPhone’s, and there’s no Timestamps box: macOS sets that for the whole computer, not for each connection.

A server that looks closer still sees your computer, in the order of the connection’s TCP options. No setting can change that.