TLS Fingerprinting and Burp Suite: JA3, JA4 and ClientHello Explained
A server can judge an HTTPS client before any page content arrives. The opening ClientHello reveals the TLS library and its preferences, allowing JA3 or JA4 fingerprints to be compared with the HTTP request that follows. This guide explains that early signal, shows why Burp Suite traffic can look inconsistent, and gives a practical before-and-after test using a browser-like TLS profile.
What the server sees first
TLS fingerprinting classifies the software behind an HTTPS request by inspecting the Transport Layer Security handshake. The ClientHello is sent in cleartext before encrypted application data, so a server can score the client before HTML, cookies, JavaScript results or most HTTP behaviour are available.
The fingerprint is not a personal identifier in the way a login or device ID is. It is a pattern formed by protocol versions, cipher suites and their order, extensions and their order, supported groups, signature algorithms, ALPN and related fields. Different TLS libraries make different choices, which is why Chrome, Firefox, Safari, Python Requests, cURL, Go and Burp Suite can produce distinguishable handshakes.
A useful diagnostic rule follows from this: changing the IP address or the User-Agent does not necessarily change the handshake. A proxy changes the apparent network origin, while the User-Agent is an HTTP header created later. If the TLS library remains the same, the underlying fingerprint can remain the same across many addresses and header variations.
Inside the ClientHello
An HTTPS session begins with the client sending a ClientHello, the server replying with a ServerHello, both sides negotiating settings and key material, and only then the HTTP request travelling over the encrypted connection. Because the first message is visible before encryption starts, it provides an early risk signal.
Fields that commonly contribute to a fingerprint include the TLS version values, offered cipher suites, cipher-suite order, extensions, extension order, supported groups and elliptic-curve point formats. In a Wireshark capture filtered to ClientHello messages, these areas can be inspected alongside server_name, supported_versions, ALPN and key_share values. A TLS 1.3 ClientHello may still show a legacy TLS 1.2 value in its main version field; actual support is carried in the supported_versions extension.
The library behind the client largely determines these choices. Chrome and Edge use BoringSSL, Firefox uses Network Security Services, legacy Microsoft stacks used SChannel, Safari uses Apple's platform stack, Python Requests commonly uses OpenSSL, Go uses crypto/tls, and Burp Suite uses Java Secure Socket Extension. The resulting mismatch is the key tell: an HTTP layer claiming Chrome while the TLS layer resembles OpenSSL, Go or Java is internally inconsistent.
JA3, JA4 and JA4+
JA3 converts five ClientHello values — TLS version, cipher suites, extensions, elliptic curves and point formats — into an ordered string and then an MD5 hash. The compact result is easy to share across logs and detection systems, and JA3S applies a comparable idea to the server's ServerHello. Its weakness is ordering: when Chrome randomised extension order in 2023, the same browser could generate different JA3 values across connections. JA3 remains useful for many non-browser clients, but it became noisier as a sole browser identifier.
JA4 was designed for that environment. It normalises order-variable fields, retains readable structure, and can include transport type, TLS version, SNI, cipher and extension counts, ALPN and sorted hashes. In an example fingerprint, t13 indicates TLS 1.3 and h2 indicates HTTP/2 negotiated through ALPN. JA4+ is broader still, covering TLS clients and servers, HTTP clients, TCP, SSH, certificates and QUIC-related traffic.
For practical testing, record both JA3 and JA4 rather than relying on one value. JA3 is useful for exact matching, while JA4 gives more inspectable context and is better suited to randomised modern handshakes. Normalised variants can also help when a checker reorders or canonicalises parts of the handshake before comparison.
Why Burp Suite traffic can be flagged
Burp Suite creates a second connection rather than passing the browser's original TLS session through unchanged. The browser talks to Burp, and Burp then opens its own upstream connection to the target. Consequently, the target sees Burp's Java-shaped handshake even when the forwarded headers look browser-like.
This explains why proxy rotation alone may not resolve a block. The address can change while the client library stays constant, leaving a repeated non-browser pattern. It also explains why a TLS-rewriting extension is relevant: it can replace the upstream ClientHello with a browser-shaped profile while preserving the request flow through Burp.
Before choosing a fix, check coherence across layers. Compare the TLS fingerprint with HTTP headers, HTTP/2 settings, ALPN, JavaScript behaviour, IP reputation and request timing. If only the TLS layer is inconsistent, a profile change may be sufficient. If several layers disagree, a real browser, an impersonation client or a managed service may be more appropriate.
A practical Burp Suite test and its limits
Four broad approaches can align the request layers:
- Run a real browser through a tool such as Playwright, Puppeteer or Selenium when JavaScript, cookies and browser behaviour matter.
- Use a TLS impersonation client such as curl-impersonate, tls-client or uTLS for lighter request-level scraping, accepting that browser profiles need maintenance.
- Route traffic through a TLS-rewriting proxy when the existing Burp Suite workflow must be retained.
- Use a managed API when TLS, rendering, proxies and retries need to operate together at scale.
For Burp Suite, install burp-awesome-tls as a Java extension through Extensions, Installed, Add, selecting the downloaded JAR. A successful load adds an Awesome TLS tab. Choose a predefined browser profile there; optionally enable the Advanced Proxy Listener so the profile is applied automatically, and note the local server address used in the route from browser to Burp to the local TLS proxy to the target. Advanced users can instead capture a browser ClientHello in Wireshark, copy its record as hex, and place it in the Hex Client Hello field.
Verify the result with the same TLS test before and after enabling the profile. In the captured test, Burp's default JA3 was 62f6a6727fda5a1104d5b147cd82e520 and its JA4 was t13d4913h2_bd868743f55c_70ae44219175. With a browser profile, JA3 became 74e530e488a43fddd78be75918be78c7 and JA4 became t13d1516h3_8daaf6152771_d8a2da3f94cd. The cipher suite changed from TLS_AES_256_GCM_SHA384 to TLS_AES_128_GCM_SHA256, and the key exchange changed from x25519 to X25519MLKEM768, confirming that the handshake itself — not merely an HTTP header — had changed.
Treat this as a targeted fix rather than a guarantee. It does not by itself solve JavaScript challenges, CAPTCHAs, behavioural detection, browser fingerprinting, account risk or IP reputation. Browser profiles also drift as browsers, TLS libraries and anti-bot models change, so manual profiles are best for debugging, authorised testing and controlled experiments. For repeated production scraping, {{OWNER_MANAGED_API_NAME}} should be evaluated against the current documented parameter, rendering requirement, credit cost and unsupported options: {{OWNER_API_PARAMETER_AND_LIMITS}}, {{OWNER_STEALTH_CREDIT_COST}} and {{OWNER_FREE_CREDIT_ALLOWANCE}}.
Frequently asked questions
What is a TLS fingerprint?
It is a summary of how a client opens a Transport Layer Security connection, usually derived from the ClientHello. Fields such as supported versions, cipher suites, extensions, supported groups and their ordering can distinguish Chrome, Firefox, Python Requests, Go, cURL and Burp Suite patterns. It describes software behaviour, not a named person.
What is the difference between JA3 and JA4?
JA3 is the older approach: five ordered ClientHello fields are joined and hashed with MD5 into a 32-character value. JA4 is newer, keeps a structured and partly readable format, normalises order-variable data, and can carry transport, ALPN and SNI context. JA3 is therefore more affected when browsers randomise extension order.
Why does Burp Suite get blocked by Cloudflare?
Burp Suite opens its own upstream connection after receiving traffic from the browser. That connection uses its Java-based TLS stack, so a target may see browser-like HTTP headers alongside a Java-shaped handshake. Anti-bot systems can treat that inconsistency as an automation signal.
Can you completely hide from TLS fingerprinting?
No. A TLS server needs handshake information to negotiate an encrypted connection. You can reduce suspicious mismatches by aligning the fingerprint with the claimed client, but JavaScript behaviour, HTTP/2 settings, cookies, IP reputation, timing and browser fingerprints may still be checked.
Does changing my User-Agent change my TLS fingerprint?
No. The User-Agent is an HTTP header sent after the handshake, while the fingerprint is produced earlier by the TLS library. Rotating headers can therefore leave a Python, Go, Java or cURL handshake unchanged.
Is bypassing TLS fingerprinting legal?
It can be legitimate for authorised security testing, debugging and some public-data workflows. Test only systems you own or are permitted to assess, respect site terms, robots guidance, rate limits and applicable law, and avoid login walls and regulated personal data without a clear legal basis. This is not legal advice.
| Property | JA3 | JA4 |
|---|---|---|
| Year | 2017 | 2023 |
| Hash length | 32 characters | 36 characters |
| Algorithm | MD5 hash of ordered ClientHello fields | Structured format with truncated Secure Hash Algorithm 256 (SHA-256) sections |
| Randomization-resistant | No, extension order changes the hash | Yes, order-variable fields are normalized |
| Extra context: TCP, HTTP/2, ALPN, SNI | Limited | Included in the fingerprint structure |
| Status | Still useful, but noisy for modern browsers | Better suited to modern TLS fingerprinting |