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.
The TLS tab
Section titled “The TLS tab”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.
Check at tls.peet.ws
Section titled “Check at tls.peet.ws”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,passwordorjwt; - headers whose values start with
BearerorBasic; Referer,Originand the body’s headers.
Export a TLS profile
Section titled “Export a TLS profile”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.
- Click TCP and switch it on.
- 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.