In this Article
A DataDome bypass, in the sense that matters to a working engineer, is not a way to defeat a security product. It is the process of making a legitimate automated client stop contradicting itself, so that a bot-detection system scoring your traffic has no reason to reject it. If your scraper collects public data and still gets 403s, the usual cause is a mismatch between what your client claims to be and what it actually is.
This guide explains how DataDome decides, why ordinary scrapers trip it, what to fix in your own stack before you touch proxies, and where the line sits between data collection and a problem you do not want. It includes our own datacenter-versus-residential measurement from 17 September 2026, and it is honest about the cases where the right answer is to stop and use an official API.
Key Facts
- What a datadome bypass really is: not a trick that defeats the product, but removing the inconsistencies in your own requests that make an automated client look nothing like the browser it claims to be.
- Where it runs: DataDome operates at the edge and states it mitigates bot attacks in under 2 milliseconds across 35+ edge PoPs (datadome.co/products/bot-protection/, as of 2026-09-17), so the decision is made before your request reaches the application.
- Five layers get scored: network identity, TLS identity, HTTP identity, runtime identity, and behavior. A mismatch between any two of them is the signal, not any single value.
- Our test, 2026-09-17: a plain request to datadome.co returned 403 from a datacenter IP and 200 from a residential IP. The same test against kasada.io and imperva.com returned 200 on both routes. One request per cell, marketing pages, not a benchmark of the products.
- What this guide does not do: no CAPTCHA solving, no token forging, no instructions for defeating a protection on a site you are not allowed to access. Those are the parts that turn scraping into a legal problem.
What is DataDome and what does it actually score?
DataDome is a commercial bot-detection service that sits in front of websites, mobile apps and APIs and classifies every request as human or automated before the application sees it. Its own product page states that it operates at the edge and mitigates bot attacks in under 2 milliseconds, with 35+ edge PoPs delivering that response time (datadome.co/products/bot-protection/, as of 2026-09-17).
Two consequences follow for anyone building a crawler. First, the decision is made at the edge, so no amount of application-level politeness helps if the request never reaches the application. Second, the decision is made on a scored profile of the request, not on a single blocked value. Swapping a user agent string changes one input to a model that reads dozens.
It is worth separating three outcomes you will see. A hard 403 with a short body is a decision that your request is automated. An interstitial challenge page is a decision that the system is unsure and wants the client to prove it can execute a browser workload. A 200 with missing content means you passed the gate but the page renders its data through JavaScript your client never ran. These three require completely different fixes, and treating them as one problem is the most common waste of engineering time in this area.
Why do compliant scrapers still get blocked?
Because detection does not ask whether you are polite. It asks whether the parts of your request agree with each other. A crawler that respects robots.txt, crawls slowly and collects only public pages can still look synthetic if its TLS handshake says Python while its user agent says Chrome 126 on Windows.
We call the way these systems read a request the 5-layer request identity model. Each layer produces evidence about what the client is, and the score comes from the agreement between layers rather than from any single value.
| Layer | What it exposes | Typical scraper mistake |
|---|---|---|
| 1. Network identity | IP address, ASN, whether the range belongs to a hosting provider, reputation history of that range, geography | Running from a cloud region whose ASN is known to host automation, then claiming to be a residential user in another country |
| 2. TLS identity | The cipher suites, extensions and their order that your HTTP library negotiates, which differ per implementation | A requests or axios TLS signature paired with a Chrome user agent string |
| 3. HTTP identity | Header set, header order, HTTP version, cookie handling, Accept and Sec-Fetch values | Five headers in alphabetical order where a real browser sends fifteen in a fixed order |
| 4. Runtime identity | Whether a JavaScript runtime exists, what it reports about the device, whether the challenge script executed | No runtime at all, or a headless runtime with automation flags left on |
| 5. Behavior | Request pacing, path order, session continuity, ratio of pages to assets, time of day | Perfectly even 200 ms intervals across 40 threads, no assets fetched, sequential ID enumeration |
The model is useful because it tells you where to look. If you are blocked before any JavaScript runs, layers 1 to 3 are the suspects. If you get a challenge page, layer 4 is doing the work. If you pass for ten minutes and then stop passing, layer 5 is what changed.
How do the five layers fail in practice?
Each layer fails in a recognisable way, and the fix is different for each.
Network identity. The cheapest signal available to any detector is the address you arrive from. Datacenter ranges are trivially identifiable because ASN ownership is public. That does not make datacenter IPs useless, it makes them honest: they say “this is infrastructure”. For an API client that is fine. For a client claiming to be a person browsing from Manchester it is a contradiction. Read our comparison of static and rotating proxies for how the choice interacts with session length.
TLS identity. Every HTTP stack negotiates TLS slightly differently, and that pattern is stable enough to fingerprint. This is why a scraper that sets perfect headers can still be classified instantly: the handshake happened before the headers were sent. The only durable fix is to send requests through a client whose TLS behaviour genuinely matches the browser you claim to be, which in practice means driving a real browser engine rather than dressing up a library.
HTTP identity. Browsers send a large, ordered, version-specific header set, including Sec-Fetch metadata and client hints. Libraries send a small set in whatever order the code adds them. Copying a header dump from your own browser once and reusing it for a year produces a different problem: a Chrome 112 header set arriving in 2026 is its own anomaly.
Runtime identity. Challenge scripts exist to make the client perform work that a real browser performs naturally. A headless browser can do this, but default automation setups announce themselves through driver flags, missing device APIs and implausible screen geometry. If you need a browser, run it properly and keep it current. Our Playwright proxy tutorial and Puppeteer guide cover the wiring.
Behavior. This is the layer engineers underestimate. Humans produce ragged traffic: they load assets, they pause, they revisit, they abandon. A crawler that fetches only HTML documents, never an image or a stylesheet, at a metronome interval, describes itself accurately as a crawler. Pacing and session continuity are cheaper to fix than anything else on this list and they are usually what breaks after an initially successful run.
What did our own datacenter versus residential test show?
We ran a small controlled check on 17 September 2026 because the question “does the exit IP alone change the outcome” deserves a measurement rather than an opinion. Method: one GET request per cell, identical browser-like headers, no JavaScript engine, no retries, plain HTTP client. Route A came straight from our server on a datacenter address. Route B went through a DataImpulse residential exit in the United States. Targets were the public marketing homepages of four bot-mitigation vendors.
| Target | Datacenter route | Residential route |
|---|---|---|
| datadome.co | 403, 771 bytes | 200, 446 KB, 1.38 s |
| humansecurity.com | 403, 5.7 KB | 200, 1.99 MB, 1.20 s |
| kasada.io | 200, 47 KB | 200, 47 KB |
| imperva.com | 200, 249 KB | 200, 249 KB |
Two readings matter. First, network identity alone flipped the outcome on two of the four deployments: the same bytes, the same headers, no browser, blocked from one address and served from another. Second, it did nothing on the other two, which is the more useful half of the result. A proxy is not a bypass. It removes one contradiction out of five.
The honest caveats: n equals one per cell, these are marketing sites rather than the protected endpoints these vendors sell for, configurations differ per customer, and results move over time. Twenty minutes later the same residential route to humansecurity.com returned 403, which is itself the point. Treat any single measurement, including ours, as a snapshot rather than a property of the product.
How does DataDome compare with other anti-bot systems?
They differ less in what they measure than in where they put the weight. All four of the systems below read network, client and behavioral evidence; the practical difference is how much they lean on making the client execute work, and how visible the decision is to you.
| System | Stated emphasis (vendor’s own site, captured 2026-09-17) | What that means for a crawler |
|---|---|---|
| DataDome | Edge mitigation in under 2 milliseconds across 35+ edge PoPs (datadome.co/products/bot-protection/) | The verdict lands before your request reaches the application, so retries against the origin achieve nothing |
| Imperva | Over 700 dimensions, combining direct client interrogation, behavior analysis, machine learning, connection characteristics and threat intelligence feeds (imperva.com/products/advanced-bot-protection-management/) | Breadth of signals, so single-signal fixes rarely move the outcome. See our Imperva and Incapsula guide |
| Kasada | Reports identifying 90% of requests as bad bots, 98% of them low-sophistication traffic that never executed Kasada’s JavaScript (kasada.io) | Client-side execution carries the weight, so a library that runs no JavaScript is filtered immediately. See our Kasada guide |
| HUMAN (PerimeterX) | No claim quoted: their product pages returned 403 to both of our routes on 2026-09-17, so we make no specification claims here | Sensor script plus challenge plus decision, in the general pattern. See our PerimeterX guide |
That last row is not a gap in our research, it is the subject of the article. A plain HTTP client from either route could not read a public marketing page, which is a fair demonstration of how little it takes to be classified as automation.
What should you fix before you touch proxies?
Most blocked scrapers are fixed on the client side, and the fixes are boring. Work through these before you spend money on infrastructure.
- Check the official route first. A documented API, a data licence, a partner feed or an export is faster to integrate, stable, and does not carry the risk profile of scraping. This is genuinely the first question, not the polite disclaimer at the end.
- Read robots.txt and the terms of service, and honour them. This is both the ethical baseline and the practical one: crawling paths the site asks you to leave alone is what gets an IP range flagged.
- Make one client consistent. Pick a browser identity and make every layer match it: TLS stack, header set and order, HTTP version, language, timezone. Half-matched is worse than honest.
- Pace like a person and vary it. Concurrency per host in the low single digits, jitter between requests, and a hard ceiling on requests per minute per site.
- Keep sessions coherent. Cookies that persist across a session, a referrer chain that makes sense, assets fetched when the page needs them.
- Back off on the first signal, not the tenth. Exponential backoff on 403, 429 and challenge responses, plus a circuit breaker that stops the job instead of hammering through it.
- Cache aggressively. The cheapest request is the one you do not send. A local cache and conditional requests cut volume more than any evasion technique.
- Identify yourself where appropriate. For research and monitoring work, a descriptive user agent with a contact URL turns an anonymous bot into an accountable one, and some sites will simply allow it.
Our guide on proxy rotation best practices covers the pacing and session side in more depth.
Which proxy type fits which job?
Once your client is consistent, the exit address is the remaining variable. The decision is about matching the claim your client makes, not about buying the most expensive option.
| Job | Use | Avoid when |
|---|---|---|
| Public pages that render server-side, moderate volume, consumer-facing site | Rotating residential with a session per logical task | You need a stable identity for a multi-step flow, or the target has no network-level gating at all |
| Multi-step workflow, cart or search state, login you are authorised to use | Sticky residential session held for the length of the workflow | The workflow is single-request, where sticky adds cost and no benefit |
| APIs, documentation, open data portals, your own infrastructure | Datacenter | The target treats hosting ASNs as automation, which our test above showed is common on consumer-facing sites |
| Mobile-first targets and app APIs | Mobile | Budget is tight and the target does not distinguish carrier traffic, since mobile costs more per gigabyte |
| Anything where you were blocked once already | Fix layers 2 to 5 first, then add network variety | Always. Rotating faster through a broken client identity just burns addresses |
DataImpulse residential is $1 per GB across 195 countries with country targeting included, HTTP, HTTPS and SOCKS5 support, and state, city, ZIP or ASN targeting on the paid tier. We do not sell static ISP addresses and we are not a managed scraping API, so if what you need is a hosted unblocker with a single endpoint, we are the wrong shape of product and it is better to say so. Compare the options in our roundup of the best proxies for web scraping.
When should you stop and use an API instead?
There is a point where continuing to engineer around a detection system stops being reasonable, and recognising it early saves both money and risk. Stop and switch when any of the following is true.
- An official API exists and covers your fields. Even a rate-limited paid API is cheaper than a crawler that needs constant maintenance.
- The data sits behind a login or a paywall. Authentication marks the boundary between public and controlled access, and crossing it without permission is where legal exposure becomes real.
- You are being challenged rather than blocked, repeatedly. A site that keeps asking the client to prove itself is telling you it does not want unattended automation on that path.
- The dataset includes personal data. Then the question is not whether you can fetch it but whether you have a lawful basis to process it.
- Your fix list has reached CAPTCHA solving or token manipulation. That is the boundary this guide does not cross.
For the legal framing in more detail, see our overview of whether web scraping is legal.
What are the limits, risks and legal boundaries?
This section exists because most guides on this topic quietly skip it.
What proxies do not do. A residential exit removes one contradiction. It does not execute JavaScript, it does not fix a mismatched TLS signature, it does not make aggressive pacing acceptable, and it does not grant permission. Our test above measured exactly this: two targets unaffected by the route change.
Legal and contractual limits. Terms of service are a contract, and breaching them can carry consequences even where the data is public. Accessing systems without authorisation is a criminal matter in many jurisdictions, including under the Computer Fraud and Abuse Act in the United States and equivalent computer-misuse law elsewhere. Personal data brings the GDPR and similar regimes into scope regardless of how public the page looked. This is general information, not legal advice, and a lawyer who knows your jurisdiction is a cheaper investment than a dispute.
Operational risks. Aggressive crawling harms the target, and a site under load will tighten its rules for everyone. Burned address ranges affect other users of the same pool. Data collected through an unstable pipeline is often quietly wrong, which is worse than missing.
Out of scope here. We do not publish CAPTCHA-solving workflows, reverse-engineered challenge payloads, token forging, or anything designed to defeat access controls on systems you are not authorised to use. Those techniques are what turn a data project into an incident, and they are also the part that ages fastest.
How do you troubleshoot a block methodically?
Work the layers in order, changing one thing at a time. Most teams change five things at once and learn nothing.
Step one, classify the response. Capture the status code, the body size and whether a challenge script is present. A 403 of a few hundred bytes, a full challenge page and a 200 with an empty data container are three different diagnoses.
Step two, test the network layer alone. Send the identical request from a different address type. If the outcome changes, you have a network-identity problem and the fix is the right exit type, not more headers. If it does not change, stop buying proxies.
Step three, test the client layer alone. From the same address, send the same request through a real browser engine. If the browser succeeds where the library failed, your problem is TLS, header or runtime identity.
Step four, test pacing. Cut concurrency to one and add jitter. If success returns, the issue was behavioral and rotation will not save you at the original rate.
Step five, look at what you are asking for. Sequential IDs, sitemap-wide sweeps and search endpoints are treated differently from ordinary page reads. Sometimes the fix is to want less data.
If you reach the end of that list and still cannot collect the data reliably, treat that as the answer rather than an obstacle: the site has decided, and the productive next move is the official channel.
What changes now that AI agents make the requests?
The signals are the same, but the traffic shape has changed, and so has what vendors advertise. DataDome now lists MCP servers alongside websites, apps and APIs as surfaces it protects (datadome.co/products/bot-protection/, as of 2026-09-17), which tells you that agent-driven traffic is being scored as its own category rather than lumped in with old-school scrapers.
Three practical consequences. First, an agent that fans one user question out into twenty page fetches produces a burst pattern that looks nothing like a person reading, so pacing and caching matter more than they did for a nightly crawler. Second, agents often run from a handful of cloud regions, which concentrates network identity exactly where it is weakest. Third, agent frameworks tend to use plain HTTP clients under the hood, which puts them back at layer two of the model with a mismatched TLS signature.
The fix is not different in kind: give the agent one coherent identity, pace it, cache what it re-reads, and route it through an exit that matches the claim it makes. Our guide to proxies for AI agents covers the pattern for fleets rather than single clients.
Frequently Asked Questions
What does a DataDome bypass actually mean?
In engineering terms it means removing the contradictions in your own client so that a detection system has no reason to classify it as automation: a consistent TLS and header identity, a runtime that can execute challenge scripts, human-like pacing, and an exit address that matches the identity you claim. It does not mean defeating the product, and techniques that target the protection itself, such as solving CAPTCHAs or forging tokens, are outside what we cover.
Why does my scraper get 403 even with a browser user agent?
Because the user agent is one string among dozens of signals. Your TLS handshake, header order, HTTP version, JavaScript runtime and request pacing are all read as well. A Chrome user agent on a Python TLS stack is a contradiction, and contradictions are exactly what these systems score.
Do residential proxies bypass DataDome?
They change one layer of five. In our own test on 17 September 2026 a plain request to datadome.co returned 403 from a datacenter IP and 200 from a residential IP, while the same change made no difference on two other vendor sites. Treat a residential exit as removing a network-level contradiction, not as a bypass, and fix client consistency and pacing first.
Is bypassing bot protection legal?
It depends on what you access and how. Collecting public data is broadly permitted in many jurisdictions, but terms of service are a contract, accessing systems without authorisation is a criminal matter in many countries, and personal data brings privacy law into scope. Scraping behind a login or paywall is where risk becomes concrete. This is general information rather than legal advice.
How can I tell whether the block is network-level or client-level?
Send the identical request from a different address type without changing anything else. If the result changes, the problem is network identity. If it does not, repeat the request from the same address through a real browser engine: if that succeeds, the problem is TLS, header or runtime identity, and no amount of proxy rotation will fix it.
Which proxy type should I use for a site protected by an anti-bot service?
Rotating residential with a session per logical task for consumer-facing public pages, sticky residential when a workflow spans several requests, datacenter for APIs and open data where hosting traffic is expected, and mobile when the target is app-first. If you were blocked once already, fix the client layers before changing exit type.
Collect public data without fighting your own stack
If your client is already consistent and the remaining problem is network identity, DataImpulse residential proxies give you geo-accurate exits at $1 per GB across 195 countries, with HTTP, HTTPS and SOCKS5, rotating or sticky sessions, and country targeting included. You can create an account and test a single target before scaling anything, or read how the pieces fit together in our web scraping use case and our guide to IP rotation.
Last updated: September 17, 2026.

State/City/Zip/ASN Targeting 



