Cómo funciona la detección de DataDome y cómo pasar limpiamente con proxies residenciales

Por qué tu scraper se estrella contra DataDome

Si alguna vez has configurado un scraper que funcionaba perfectamente durante días y de repente empieza a recibir páginas vacías, redirecciones infinitas o CAPTCHAs interminables, probablemente te has topado con DataDome. Es uno de los sistemas anti-bot más agresivos del mercado y protege sitios como grandes editores de noticias, plataformas de e-commerce y marketplaces.

Este artículo no trata sobre cómo «hackear» DataDome. Trata sobre entender cómo detecta el tráfico automatizado para que, como ingeniero de scraping o investigador de seguridad legítimo, puedas configurar tu infraestructura de forma que el acceso autorizado pase sin fricción. Si tu caso de uso es legítimo —monitoreo de precios con autorización, auditorías de SEO, investigación de seguridad— mereces una configuración que no te bloquee injustamente.

La pila de detección de DataDome: cuatro capas

DataDome no se basa en una sola señal. Opera con un modelo de «defensa en profundidad» donde cuatro capas se refuerzan mutuamente. Veamos cada una con el nivel técnico que un scraping engineer necesita.

1. Reputación de IP: bases de datos comerciales y análisis ASN

La primera decisión de DataDome ocurre antes de que tu solicitud llegue al servidor de origen. El sistema consulta bases de datos de reputación de IP comerciales (MaxMind, IP2Location, Neustar) y analiza el ASN (Autonomous System Number) de la IP entrante.

Los rangos de IP de datacenters están ampliamente catalogados. Si tu solicitud viene de un ASN como OVH (AS16276), DigitalOcean (AS14061), Hetzner (AS24940) o Amazon (AS16509), DataDome la marca inmediatamente con un score alto de sospecha. No importa si la IP nunca ha aparecido en listas de abuso: el mero hecho de pertenecer a un rango de hosting es suficiente para activar controles adicionales.

Las IPs residenciales (AS de ISPs como Comcast, Orange, Movistar) y móviles (AS de operadores como Vodafone, T-Mobile) reciben un score base mucho más favorable. Esto es por qué los proxies residenciales y móviles son esenciales para cualquier automatización que necesite pasar por DataDome.

2. Huella TLS: JA3, JA4 y el orden de cifrados

Cuando tu cliente inicia un handshake TLS, los primeros paquetes contienen el ClientHello, que incluye la lista de cifrados soportados, extensiones TLS y el orden en que se presentan. DataDome captura estos datos y genera una huella JA3 (y más recientemente JA4) para compararla contra su base de datos de fingerprints conocidos.

El problema es que cada cliente TLS tiene una firma distinta:

• Chrome en Windows: cipher order específico con AES-GCM al frente, extensiones como application_layer_protocol_negotiation con h2.
• Python requests: usa la librería urllib3 con OpenSSL, generando un JA3 completamente distinto al de cualquier navegador real.
• Node.js: el motor V8 de Node produce un JA3 diferente al de Chrome a pesar de compartir el mismo motor JavaScript.

DataDome mantiene un catálogo de JA3/JA4 por navegador, versión y sistema operativo. Si tu huella TLS no coincide con lo que un navegador real de ese User-Agent debería producir, tu score de sospecha sube drásticamente.

Un User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)... con un JA3 de Python/OpenSSL es una contradicción inmediata. DataDome lo detecta en milisegundos.

3. Fingerprinting de navegador: canvas, WebGL, audio, navigator

Una vez que la conexión TLS se establece, DataDome inyecta un script JavaScript que ejecuta una batería de pruebas de fingerprinting:

• Canvas fingerprint: renderiza texto y formas en un canvas invisible, luego extrae el hash de los píxeles resultantes. Esto captura diferencias en motores de renderizado, suavizado de fuentes y drivers gráficos.
• WebGL fingerprint: consulta los parámetros del renderer y vendor de WebGL (RENDERER, VENDOR, MAX_TEXTURE_SIZE). Los headless browsers frecuentemente reportan valores genéricos como Mesa o SwiftShader.
• Audio fingerprint: usa la Web Audio API para generar una señal y mide cómo el procesador de audio del sistema la procesa. Los entornos sin hardware de audio real producen resultados anómalos.
• navigator properties: navigator.webdriver, navigator.plugins, navigator.languages, navigator.hardwareConcurrency. Un navegador headless típicamente tiene navigator.webdriver === true y una lista de plugins vacía.
• screen y window dimensions: dimensiones de pantalla inconsistentes con el User-Agent declarado (por ejemplo, un móvil con resolución de escritorio).

DataDome combina todas estas señales en un vector y lo compara contra su modelo. Los headless browsers estándar (Puppeteer sin stealth, Selenium sin modificaciones) producen fingerprints que son inmediatamente reconocibles.

4. Señales de comportamiento: dinámica de ratón, scroll y timing

La capa final es la más sofisticada. DataDome analiza cómo interactúas con la página:

• Mouse dynamics: velocidad, aceleración, curvas de trayectoria. Un ratón real no se mueve en líneas rectas perfectas a velocidad constante.
• Scroll patterns: ritmo, pausas naturales, aceleración y desaceleración.
• Click timing: intervalo entre carga de página y primer click. Los bots suelen hacer click inmediatamente después de que la página carga.
• Keyboard dynamics: velocidad de escritura, pausas entre teclas, uso de atajos.

Estas señales se procesan con modelos de machine learning entrenados con millones de sesiones. El resultado es un score de «humanidad» que determina si tu sesión recibe el datadome cookie de confianza o un desafío CAPTCHA.

El cookie datadome y el flujo de desafío CAPTCHA

Cuando un visitante pasa por las cuatro capas de detección, DataDome emite un cookie llamado datadome. Este cookie es un token cifrado que codifica el resultado del análisis y se envía con cada solicitud posterior al dominio protegido.

El flujo típico es:

1. Primera solicitud: DataDome intercepta la petición (generalmente via CDN o server-side integration). Si la IP y el JA3 son sospechosos, devuelve un challenge JavaScript.
2. Ejecución del JS: el script de fingerprinting se ejecuta en el navegador. Si el resultado es limpio, se emite el cookie datadome y se redirige al contenido original.
3. Si el JS es sospechoso: se presenta un CAPTCHA (generalmente reCAPTCHA v3 o hCaptcha). El usuario debe resolverlo para recibir el cookie.
4. Solicitudes posteriores: el cookie datadome se envía con cada petición. DataDome lo valida server-side y, si es válido, deja pasar la solicitud al origen.

El cookie tiene una duración limitada (típicamente 24 horas) y está vinculado a la IP y al fingerprint del navegador. Si cambias tu IP o tu fingerprint, el cookie deja de ser válido.

Por qué los proxies residenciales y móviles son esenciales

DataDome clasifica las IPs en categorías con diferentes niveles de confianza:

Tipo de IP	Ejemplo de ASN	Confianza base DataDome	Probabilidad de CAPTCHA
Datacenter	AS16509 (AWS), AS14061 (DO)	Muy baja	Alta (>90%)
Residencial	AS7922 (Comcast), AS3352 (Movistar)	Alta	Baja (<10%)
Móvil	AS21407 (Vodafone ES), AS21928 (T-Mobile US)	Muy alta	Muy baja (<5%)

Los proxies de datacenter son prácticamente inútiles contra DataDome. Incluso con un navegador perfectamente configurado, la IP de datacenter activa el challenge JavaScript y, frecuentemente, el CAPTCHA directo.

Los proxies residenciales ofrecen IPs que pertenecen a ISPs reales. DataDome ve una IP de un ISP doméstico y le otorga confianza base alta. Los proxies móviles van un paso más allá: las IPs de redes móviles 4G/5G tienen la confianza más alta porque es donde los humanos legítimos navegan desde dispositivos móviles.

Para automatización contra sitios protegidos por DataDome, necesitas al menos proxies residenciales y, para los casos más estrictos, proxies móviles.

Con ProxyHat, puedes configurar la geo-localización para que tu IP residencial coincida con el público objetivo del sitio:

# Proxy residencial en España
http://user-country-ES:PASSWORD@gate.proxyhat.com:8080

# Proxy residencial en Alemania, ciudad de Berlín
http://user-country-DE-city-berlin:PASSWORD@gate.proxyhat.com:8080

# Proxy móvil en Estados Unidos
http://user-country-US-mobile:PASSWORD@gate.proxyhat.com:8080

Configuración legítima: navegador stealth + proxy residencial

La clave para pasar limpiamente por DataDome es no modificar nada que un navegador real no modificaría. Esto significa usar un navegador real (o un wrapper que preserva sus huellas) con una IP residencial geo-coincidente.

Ejemplo 1: Playwright con stealth plugin y proxy residencial (Python)

import asyncio
from playwright.async_api import async_playwright

async def scrape_with_datadome():
    async with async_playwright() as p:
        # Proxy residencial geo-coincidente
        proxy = {
            "server": "http://gate.proxyhat.com:8080",
            "username": "user-country-ES",
            "password": "TU_PASSWORD"
        }

        browser = await p.chromium.launch(
            headless=False,  # Headless es más detectable
            proxy=proxy,
            args=[
                "--disable-blink-features=AutomationControlled",
            ]
        )

        context = await browser.new_context(
            viewport={"width": 1920, "height": 1080},
            locale="es-ES",
            timezone_id="Europe/Madrid",
            user_agent=(
                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                "AppleWebKit/537.36 (KHTML, like Gecko) "
                "Chrome/125.0.0.0 Safari/537.36"
            ),
        )

        # Eliminar navigator.webdriver
        await context.add_init_script("""
            Object.defineProperty(navigator, 'webdriver', {
                get: () => undefined
            });
        """)

        page = await context.new_page()

        # Simular comportamiento humano antes de interactuar
        await page.goto("https://ejemplo-protegido-datadome.com")
        await asyncio.sleep(3)  # Pausa natural

        # Movimientos de ratón naturales
        await page.mouse.move(500, 300)
        await asyncio.sleep(0.5)
        await page.mouse.move(600, 350, steps=15)
        await asyncio.sleep(1)

        # Scroll natural
        await page.evaluate("window.scrollBy(0, 300)")
        await asyncio.sleep(2)

        content = await page.content()
        print(f"Página cargada: {len(content)} caracteres")

        await browser.close()

asyncio.run(scrape_with_datadome())

Ejemplo 2: Puppeteer con stealth y proxy residencial (Node.js)

const puppeteer = require('puppeteer');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');
const puppeteerExtra = require('puppeteer-extra');

puppeteerExtra.use(StealthPlugin());

async function scrapeDatadome() {
    const browser = await puppeteerExtra.launch({
        headless: false,
        args: [
            '--proxy-server=http://gate.proxyhat.com:8080',
            '--disable-blink-features=AutomationControlled',
            '--no-sandbox',
        ],
    });

    const page = await browser.newPage();

    // Autenticación del proxy
    await page.authenticate({
        username: 'user-country-FR',
        password: 'TU_PASSWORD',
    });

    // Configurar locale y viewport consistentes
    await page.setExtraHTTPHeaders({
        'Accept-Language': 'fr-FR,fr;q=0.9,en;q=0.8',
    });

    await page.setViewport({ width: 1440, height: 900 });

    // Navegar con espera realista
    await page.goto('https://sitio-protegido-datadome.fr', {
        waitUntil: 'networkidle2',
    });

    // Pausa humana
    await humanDelay(2000, 4000);

    // Simular lectura con scroll gradual
    await page.evaluate(() => {
        window.scrollBy({ top: 400, behavior: 'smooth' });
    });
    await humanDelay(1500, 3000);

    const data = await page.evaluate(() => document.title);
    console.log('Título:', data);

    await browser.close();
}

function humanDelay(min, max) {
    const ms = min + Math.random() * (max - min);
    return new Promise(r => setTimeout(r, ms));
}

scrapeDatadome();

Ejemplo 3: Sesión sticky con proxy residencial para flujos multi-página

Cuando necesitas navegar múltiples páginas manteniendo la misma IP (para preservar el cookie datadome), usa sesiones sticky:

import requests
from requests.sessions import Session

# Sesión sticky: misma IP durante la duración de la sesión
proxy_url = "http://user-session-mi-sesion-123-country-DE:PASSWORD@gate.proxyhat.com:8080"

proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

session = Session()
session.proxies = proxies

# Nota: requests puro NO pasa DataDome por falta de JS.
# Esto es útil para APIs internas o endpoints que no tienen
# el challenge JS de DataDome, o para mantener cookies
# obtenidas previamente con un navegador real.

# Primera solicitud - DataDome puede devolver challenge
response = session.get(
    "https://api.sitio-protegido.com/v1/data",
    headers={
        "User-Agent": (
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
            "AppleWebKit/537.36 (KHTML, like Gecko) "
            "Chrome/125.0.0.0 Safari/537.36"
        ),
        "Accept": "application/json",
        "Accept-Language": "de-DE,de;q=0.9",
    },
    timeout=30,
)

print(f"Status: {response.status_code}")
print(f"Cookies: {session.cookies.get_dict()}")

Qué hace que un navegador «stealth» pase las pruebas

Los plugins de stealth como puppeteer-extra-plugin-stealth y los patches de Playwright abordan las señales más obvias, pero hay matices:

Señales que los stealth plugins corrigen bien

• navigator.webdriver → se elimina o se redefine como undefined.
• Longitud de navigator.plugins → se simulan plugins reales.
• window.chrome → se inyecta el objeto que Chrome real tiene.
• Permisos de navigator.permissions.query → se corrigen las respuestas.
• navigator.languages → se asegura consistencia con los headers HTTP.

Señales que siguen siendo problemáticas

• JA3/JA4 mismatch: si usas Playwright con Chromium compilado diferente al Chrome establecido, el JA3 no coincidirá con el User-Agent declarado. Solución: usa una versión de Chromium que coincida con un Chrome real release.
• WebGL renderer: los entornos sin GPU real reportan SwiftShader o Mesa. Solución: ejecutar en máquinas con GPU o usar servicios de navegador en la nube.
• Canvas fingerprint: en headless, el anti-aliasing se comporta diferente. Solución: usar headless: false o un servicio de navegador real.
• Comportamiento: ningún stealth plugin simula movimientos de ratón humanos. Tienes que implementarlo tú.

El marco ético: por qué DataDome existe y cómo operar legítimamente

DataDome protege sitios contra abuso real: scraping competitivo agresivo, credential stuffing, DDoS a nivel de aplicación, scalping de inventario y fraudes. Estos son problemas serios que justifican la existencia de sistemas anti-bot.

Como ingeniero de scraping, debes operar dentro de un marco ético:

• Respeta los rate limits: si un sitio permite 10 solicitudes por segundo, no envíes 100. Los proxies residenciales no son una licencia para saturar servidores.
• No uses solvers de CAPTCHA: si DataDome te presenta un CAPTCHA, significa que tu configuración no es lo suficientemente limpia. Resolver CAPTCHAs a escala no es acceso legítimo; es evasión activa.
• Respeta robots.txt: verifica las directivas del sitio. Si un path está prohibido, no lo escrapees.
• Verifica los términos de servicio: algunos sitios prohíben explícitamente el scraping. Otros lo permiten con limitaciones.
• GDPR y CCPA: si escrapeas datos personales, estás sujeto a regulaciones de privacidad. No es solo ético; es legal.
• Identifícate cuando sea posible: algunos sitios permiten scraping con un User-Agent identificable y rate limits razonables.

Cuando DataDome significa «usa la API oficial»

No todos los sitios protegidos por DataDome merecen ser scrapeados. Algunos ofrecen APIs oficiales que son la vía correcta:

Tipo de sitio	Ejemplo	¿API oficial?	Recomendación
Editores de noticias	Le Monde, Die Zeit	A veces (RSS, partnerships)	Usar RSS/API si existe; negociar acceso
E-commerce grande	Amazon, Zalando	Sí (Product Advertising API)	Usar la API oficial siempre
Redes sociales	Instagram, TikTok	Parcial (Graph API)	Usar API oficial; scraping viola ToS
Marketplaces B2B	ThomasNet, Kompass	No	Scraping legítimo con proxies residenciales
Comparadores de precios	Sites de viajes, seguros	Algunos (affiliate APIs)	Verificar API de afiliados primero

Antes de invertir horas configurando stealth browsers y proxies residenciales, verifica si el sitio ofrece una API. A menudo es más fiable, más rápida y legalmente más segura. Para más contextos donde los proxies residenciales son la herramienta correcta, consulta nuestro caso de uso de web scraping.

Comparación de enfoques contra DataDome

Enfoque	Pasa IP check	Pasa JA3/JA4	Pasa fingerprinting	Pasa comportamiento	Costo
requests + datacenter proxy	No	No	No	No	Bajo
Selenium + datacenter proxy	No	Parcial	No	No	Medio
Playwright stealth + residential proxy	Sí	Parcial	Parcial	No	Medio
Playwright stealth + mobile proxy	Sí	Parcial	Parcial	No	Alto
Navegador real + residential proxy + comportamiento humano	Sí	Sí	Sí	Sí	Alto

La conclusión es clara: no existe un atajo técnico. La única forma fiable de pasar por DataDome es parecer un humano real navegando desde una conexión residencial o móvil legítima.

Configuración de rotación de IPs con ProxyHat

Para scraping a escala, necesitas rotar IPs residenciales entre solicitudes o mantener sesiones sticky para flujos multi-página:

Rotación por solicitud

Cada solicitud usa una IP residencial diferente. Ideal para scraping de una sola página por IP:

# Sin parámetro de sesión: IP nueva cada solicitud
curl -x http://user-country-ES:PASSWORD@gate.proxyhat.com:8080 \
     "https://ejemplo-datadome.com/pagina-1"

# Siguiente solicitud = IP diferente
curl -x http://user-country-ES:PASSWORD@gate.proxyhat.com:8080 \
     "https://ejemplo-datadome.com/pagina-2"

Sesión sticky (misma IP durante 10-30 minutos)

Para flujos que requieren mantener el cookie datadome entre múltiples páginas:

# Misma sesión = misma IP durante la vida de la sesión
curl -x http://user-session-abc123-country-ES:PASSWORD@gate.proxyhat.com:8080 \
     "https://ejemplo-datadome.com/pagina-1"

curl -x http://user-session-abc123-country-ES:PASSWORD@gate.proxyhat.com:8080 \
     "https://ejemplo-datadome.com/pagina-2"

Consulta nuestras opciones de precios para elegir el plan de proxies residenciales que mejor se adapte a tu volumen, y nuestra página de ubicaciones para verificar la cobertura geográfica que necesitas.

Conclusiones clave

Key Takeaways

• DataDome usa cuatro capas de detección: reputación de IP, huella TLS (JA3/JA4), fingerprinting de navegador y señales de comportamiento. Todas deben estar limpias para pasar.
• Los proxies de datacenter son esencialmente inútiles contra DataDome. Los proxies residenciales y móviles son necesarios.
• El JA3/JA4 debe coincidir con el User-Agent declarado. Usa versiones de Chromium que coincidan con releases de Chrome reales.
• Los stealth plugins corrigen señales obvias pero no simulan comportamiento humano. Tienes que implementar pausas, movimientos de ratón y scroll naturales.
• Si DataDome te muestra un CAPTCHA, tu configuración no es lo suficientemente limpia. No uses solvers de CAPTCHA; mejora tu configuración.
• Siempre verifica si existe una API oficial antes de scrapar. A veces es la solución correcta y más sostenible.
• Opera éticamente: respeta rate limits, robots.txt, términos de servicio y regulaciones de privacidad.

Para más información sobre cómo configurar proxies residenciales y móviles para tus proyectos de scraping legítimo, explora nuestro caso de uso de tracking SERP o consulta los planes de ProxyHat.