When a flood clears the JavaScript challenge, returns its clearance cookie on every request and presents the TLS fingerprint of a current browser, the cheapest Layer 7 filters report nothing wrong. That is a headless browser DDoS: an application-layer denial-of-service attack driven through real browser engines running without a screen, and telling it apart from customers is what a DDoS test of the application layer has to put a number on.
How a headless browser DDoS works
A headless browser is a full browser engine with no display, driven by automation instead of a person. It parses HTML, runs JavaScript, stores cookies and opens connections with the browser's own TLS and HTTP/2 stack.
That is the whole point of using one. Every check built to separate a script from a browser finds a browser:
- A JavaScript challenge runs and returns the right answer, because there is a real engine to run it.
- The cookie round trip works, because cookies are kept like any browser keeps them.
- The JA3 or JA4 fingerprint matches a real browser build, because the handshake comes from one.
The price is paid in hardware. Each client runs a whole engine, with its own memory and CPU, so one machine drives far fewer clients than a script that only sends requests. Headless floods are therefore smaller in request count and aimed where each request costs the most: search, login, basket and other uncached paths. They are often paired with residential proxies, so the sources look like homes as well as browsers.
Why it matters under attack
Passing the challenge proves an engine, not a person
Many stacks treat a solved challenge as clearance for the rest of the session. Against scripts that is reasonable. Against headless browsers it hands the attacker a pass, and every later request rides on it.
The attacker must choose between being countable and paying again
A client that keeps its clearance cookie has given itself an identity, so a per-session limit on an expensive endpoint can count it. A client that throws the cookie away to escape that limit must solve the challenge again for every new session. That burns its own CPU and leaves its own pattern: many fresh sessions, each solving once, each making a handful of costly requests.
Either choice leaves a mark. The defence has to be looking for both.
Whole page loads hide the expensive request
A headless client that renders the full page also fetches its images and scripts, which the CDN serves from cache. In aggregate the traffic mix looks normal. The damage is in the one uncached request per page, which is why Layer 7 DDoS detection has to baseline each endpoint rather than the site. Automation that skips images and fonts to save bandwidth shows the opposite tell: page requests with too few assets behind them.
What hardens against it
- Use the challenge as one signal, not as clearance. Keep scoring the session after it passes.
- Fingerprint beyond the user agent, and compare the layers with each other: the TLS handshake, HTTP/2 settings and frame order, and the environment properties a script can observe in the page. A sudden majority of sessions sharing one exact environment on one endpoint is a population shift, even when each session looks fine.
- Limit cost per session and per endpoint, not only requests per address, so the cookie the attacker keeps becomes the thing that is counted.
- Watch behaviour across the session: navigation path, timing, and whether the page is used or only fetched.
Each of these can catch real users too: assistive technology, privacy browsers, monitoring robots and customers' own automation. Bot management settings that are tuned against a headless flood need to be checked against those clients as well.
What a DDoS test measures
An authorised test drives real browser engines from its own generators at the expensive paths, alongside a model of real users. It reads:
- Which layer first separated the two: challenge, fingerprint, per-session limit, behaviour, or none of them.
- Time to an enforceable rule, from the first headless session to the moment one is dropped.
- False positives on the awkward real clients listed above.
- Origin cost per headless session, the backend work one session triggers, which sets how few sessions an attacker would need.
- Whether the per-session limit still applies when the test clients discard their cookies.
Building that real-user model so it includes the clients most likely to be caught, and running it beside the flood, is the method set out in Layer 7 DDoS testing.