Skip to content

JA3 and JA4 fingerprints: how bot products identify clients

How JA4 fingerprint bot detection works, where Cloudflare, AWS WAF and Fastly expose JA3 and JA4, and why a curl test with a crawler user agent proves little.

By Crawlito · 9 min read

In short

  • JA3 and JA4 summarise the TLS ClientHello a client sends before any HTTP header, so changing the user agent in curl does not change the fingerprint a bot product sees.
  • A JA4 fingerprint has three parts, such as t13d1516h2_8daaf6152771_e5627efa2ab1: a readable prefix, a hash of the sorted cipher suites and a hash of the sorted extensions plus signature algorithms.
  • Cloudflare exposes cf.bot_management.ja3_hash and cf.bot_management.ja4 only on Enterprise plans with Bot Management; AWS WAF inspects JA3 and JA4 only on CloudFront and Application Load Balancers; Fastly VCL has tls.client.ja3_md5 and tls.client.ja4.
  • A curl test that borrows a crawler's user agent differs from the real crawler in source network, TLS fingerprint and HTTP behaviour, so it can only prove what rules keyed on the user agent alone do.
  • OpenAI and Anthropic document user agents and IP lists for their crawlers, not TLS fingerprints, and FoxIO warns that JA4 values change as TLS libraries update, so allow real crawlers by verified bot status or published IPs rather than by fingerprint.
On this page

JA3 and JA4 are fingerprints of the TLS handshake: they summarise the cipher suites, extensions and other values a client offers in its ClientHello, before it sends a single HTTP header. Bot products such as Cloudflare Bot Management, AWS WAF and Fastly compute them from the TLS handshake and let rules match on them. That is why a curl request with GPTBot's user agent can be blocked while the real GPTBot is not: the header says GPTBot, but the handshake still says curl, and the request still comes from your network.

This post covers how the two fingerprints are built, where each platform exposes them, how rules use them, and what a self-test with a borrowed user agent can and cannot prove. For the curl commands themselves, see seeing your page as an AI crawler with curl. For checking crawler IPs, see how to verify real AI crawlers.

What a TLS fingerprint is

Every HTTPS connection starts with a ClientHello message. In it, the client lists the TLS versions, cipher suites, extensions, curves and signature algorithms it supports, in an order its TLS library chooses. Chrome, Firefox, curl, Python's requests library and a Go HTTP client each build that message differently, so the combination works like a signature of the software, not of the person.

Cloudflare's JA3/JA4 fingerprint documentation puts it this way: each type of client has its own characteristics, so the fingerprint stays the same across destination IPs, ports and certificates. Three consequences follow:

  • The fingerprint is set before HTTP. Your User-Agent, Accept and other headers travel inside the encrypted connection, after the fingerprint already exists. Changing them does not change it.
  • Many clients share one fingerprint. Every copy of the same browser version or HTTP library produces the same value. Cloudflare notes that a group of similar requests may share the same fingerprint, and that a mobile app produces the same fingerprint across devices and users. A rule on a fingerprint acts on that whole group, not on one client.
  • There is no fingerprint without TLS. Cloudflare computes it during the handshake, so plain HTTP requests have none, and a resumed TLS session skips the full handshake, so no new fingerprint is calculated.

How JA3 is computed

JA3 came first. The original JA3 repository takes five fields from the ClientHello, in this order: TLS version, cipher suites, extensions, elliptic curves and elliptic curve point formats. Values within a field are joined with dashes, fields with commas, and the whole string is MD5-hashed into a 32-character value. GREASE values, the random placeholders browsers add to keep servers tolerant, are ignored.

769,47-53-5-10-49161-49162-49171-49172-50-56-19-4,0-10-11,23-24-25,0
-> ada70206e40642a3e4461f35503241d5

JA3 keeps the order in which the client lists its extensions. When Chromium started randomising extension order in 2023, one browser could produce many JA3 values, which is one reason the method was revised. The Salesforce repository was archived on 1 May 2025, and its README says the project is no longer maintained by Salesforce and that JA3's original author maintains current TLS fingerprinting work in FoxIO's JA4 repository.

How JA4 is computed

JA4 sorts the cipher suites and extensions before hashing, so a client that shuffles them still gets one value. It also keeps a readable prefix. The format is a_b_c, and the JA4 technical details use this example:

t13d1516h2_8daaf6152771_e5627efa2ab1
PartExampleWhat it encodes
Protocoltt for TLS over TCP, q for QUIC, d for DTLS
TLS version13Highest non-GREASE version offered, here TLS 1.3
SNIdd if the client sent a server name, i if not
Cipher count15Number of cipher suites, GREASE excluded
Extension count16Number of extensions, GREASE excluded
ALPNh2First and last characters of the first ALPN value, 00 if none
JA4_b8daaf6152771First 12 hex characters of a SHA-256 of the sorted cipher suites
JA4_ce5627efa2ab1First 12 hex characters of a SHA-256 of the sorted extensions (minus SNI and ALPN), then the signature algorithms in their original order

Because of the readable prefix, you can learn something without a lookup table. A value starting t13i came from a client that did not send a server name, which browsers normally do. A different ALPN pair means the client offered a different HTTP protocol first. Even curl's own flags change it: --no-alpn disables the ALPN extension, which turns the last two characters of the prefix into 00 and lowers the extension count by one.

FoxIO warns that JA4 values change as TLS libraries are updated, about once a year, so no fingerprint should be treated as permanent. On licensing, JA4 itself is BSD 3-Clause, like JA3; the other members of the JA4+ suite, such as JA4H for HTTP clients and JA4T for TCP, are under the FoxIO License.

Where Cloudflare, AWS WAF and Fastly expose JA3 and JA4

All three platforms compute the fingerprints at the edge. They differ in who can use them and where.

PlatformFieldsAvailability at the time of writing
Cloudflarecf.bot_management.ja3_hash, cf.bot_management.ja4; in Workers, request.cf.botManagement.ja3Hash and ja4Enterprise plan with Bot Management
AWS WAFJA3Fingerprint and JA4Fingerprint request components; ja3Fingerprint and ja4Fingerprint log fieldsCloudFront distributions and Application Load Balancers only
Fastlytls.client.ja3_md5, tls.client.ja4 VCL variablesRead-only, in vcl_recv, vcl_hash, vcl_deliver and vcl_log

Cloudflare

Cloudflare's field reference for cf.bot_management.ja4 lists it as a string that requires Enterprise with Bot Management. You can use the fingerprints in WAF custom rules, Transform Rules and Workers, and you can read them in Security Events, Security Analytics, Bot Analytics and Logs. Bot Management also attaches JA4 Signals, observations Cloudflare has seen globally for each JA4 over the last hour, such as browser_ratio_1h (the share of that fingerprint's requests sent with browser user agents) and ips_rank_1h. The fingerprints may be absent when Bot Management is skipped for a request.

Cloudflare's documented uses are a block or challenge rule for one fingerprint tied to an attack, and a Skip rule for a fingerprint your own mobile app uses:

(cf.bot_management.ja4 eq "t13d1516h2_8daaf6152771_e5627efa2ab1")

AWS WAF

AWS WAF lists JA3 and JA4 as request components for string match, regex match, regex pattern set and size constraint statements. The JA3 value is 32 characters and the JA4 value 36. You copy a value from your web ACL logs, which means logging must be on, and every rule must set a fallback behaviour for requests where no fingerprint could be calculated:

json
{
  "Name": "block-one-tls-client",
  "Priority": 10,
  "Statement": {
    "ByteMatchStatement": {
      "FieldToMatch": { "JA4Fingerprint": { "FallbackBehavior": "NO_MATCH" } },
      "PositionalConstraint": "EXACTLY",
      "SearchString": "t13d1516h2_8daaf6152771_e5627efa2ab1",
      "TextTransformations": [{ "Priority": 0, "Type": "NONE" }]
    }
  },
  "Action": { "Block": {} },
  "VisibilityConfig": {
    "SampledRequestsEnabled": true,
    "CloudWatchMetricsEnabled": true,
    "MetricName": "block-one-tls-client"
  }
}

On a block rule, keep the fallback at NO_MATCH. With MATCH, every request without a fingerprint is blocked too. For the managed bot rules on the same platform, see AWS WAF Bot Control and AI crawlers.

Fastly

Fastly's client connection variables include tls.client.ja3_md5 and tls.client.ja4, plus lower-level ones such as tls.client.ciphers_list. The simplest use is to pass the fingerprint to your origin so it shows up in your own logs:

vcl
sub vcl_recv {
  set req.http.X-Client-JA4 = tls.client.ja4;
}

Fastly's page notes that relying on this data can add ossification risk to the internet, a reminder that fingerprints describe today's libraries, not a fixed standard. Fastly's managed bot features are covered in Fastly bot management and AI crawlers.

What a curl self-test can and cannot prove

When you send curl -A "...GPTBot..." from your laptop, three things differ from the real crawler, and bot products can read all three:

SignalYour curl testThe real crawler
Source networkYour home, office or cloud IPThe operator's published ranges
TLS fingerprintcurl and its TLS libraryWhatever stack the operator uses, which is not published
HTTP behaviourcurl's header set, order and HTTP versionThe crawler's own

A real crawler can also carry signals your test cannot copy at all, such as a Web Bot Auth signature or a place on Cloudflare's verified bots list.

So the test can prove:

  • What your origin returns for that user-agent string when nothing upstream steps in.
  • Whether a rule keyed on the user agent alone blocks, challenges or allows the name.
  • What your HTML contains, as the curl guide shows.

It cannot prove:

  • Whether the real crawler passes rules based on verified bot status, IP ranges, ASN or country.
  • Whether a bot score or fingerprint rule treats the real crawler like your request. A fingerprint rule that blocks curl's handshake may never see the real crawler, and one that the real crawler trips may never see yours.
  • That a block you see also hits the real crawler. Rules that block "claims to be a bot, is not verified" are designed to stop exactly your test, as the Cloudflare fake Google bot rule shows.

The reliable check is the edge's own record of real requests. Filter your Cloudflare Security Events, AWS WAF logs or Fastly logs for the crawler's user agent, keep only requests from verified bots or published IP ranges, and read the action and status for those. If verified crawler requests are allowed and your curl test is blocked, the protection is working as intended.

How to use fingerprints without blocking real crawlers

Fingerprints are good at one job: finding a group of clients that behaves badly and acting on that group. They are a poor way to let good crawlers in.

  1. Do not allow crawlers by JA3 or JA4. At the time of writing, OpenAI's and Anthropic's crawler documentation lists user agents and IP ranges but no TLS fingerprint, values change when libraries update, and any scraper using the same library shares the value. Allow by verified bot status or published IP ranges instead.
  2. Do not block a common library's fingerprint outright. Many legitimate tools, monitors and some crawlers are built on the same HTTP libraries as scrapers. Block a fingerprint only when it matches abusive traffic in your logs, and prefer a challenge or rate limit to a block.
  3. Order exceptions first. Put rules that skip or allow verified bots before any fingerprint rule, so a crawler that happens to share a fingerprint with a scraper is never evaluated against it.
  4. Plan for empty values. Plain HTTP, resumed sessions and requests where Bot Management did not run can have no fingerprint. Decide what happens then, and on AWS WAF set the fallback on purpose.
  5. Review rules as clients change. A fingerprint that matched an attack last year may now match a new library release.

Frequently asked questions

Can I change my JA4 fingerprint by changing the user agent in curl?

No. The fingerprint comes from the TLS ClientHello, which is sent before any HTTP header. Options that change what curl offers in the handshake do change it: --no-alpn disables the ALPN extension, and --ciphers sets the cipher suites curl uses for TLS 1.2 and older.

What is the difference between JA3 and JA4?

JA3 is an MD5 hash of five ClientHello fields in the order the client sent them. JA4 sorts the cipher suites and extensions, adds the signature algorithms, and keeps a readable prefix with the protocol, TLS version, SNI, counts and ALPN, so clients that randomise extension order still get one value.

Do I need Cloudflare Enterprise to see JA3 or JA4?

At the time of writing, yes. Cloudflare's documentation says JA3 and JA4 fingerprints are available only to Enterprise customers who have purchased Bot Management.

Where can I find GPTBot's or ClaudeBot's JA4 fingerprint?

Neither OpenAI's nor Anthropic's crawler documentation lists one at the time of writing. Verify their crawlers with the IP lists they do publish (gptbot.json and the other OpenAI files, and Anthropic's bots.json), and treat any fingerprint you see in your own logs as subject to change.

Why is my curl test blocked when the real crawler gets through?

Your request comes from a different network, carries curl's TLS fingerprint and fails any verified bot check, so rules that look past the user agent treat it as a different client. Check the edge logs for verified crawler requests to see what the real crawler receives.

Check what real crawler access looks like

A curl test answers one narrow question. To see whether the main AI crawlers can fetch an important page, run the free check. If you want edge rules, fingerprints and logs reviewed together with evidence for each finding, an audit covers the full site.

Filed under CDN and bot protection. Topics: bot-protection, tls, curl, waf, troubleshooting