Entrada

Playwright anti-bot: cinco niveles medidos

Mismo Chrome y mismo perfil: 403 si lo lanza Playwright, 200 si lo lanzas tú. Te explico qué mira cada defensa anti-bot y cuándo conviene buscar otra fuente.

Playwright anti-bot: cinco niveles medidos
0:00 / 18:24
Más formatos
Diapositiva 1 de 15

Tienes una URL que devuelve 403. Le pones un User-Agent de Chrome y sigue devolviendo 403. Abres un navegador automatizado y aparece un reto que no termina nunca. Lanzas ese mismo navegador a mano, resuelves el reto una vez y funciona.

No has cambiado el sitio: has cambiado de nivel.

La protección anti-bot no es un muro, es una escalera de cinco peldaños. Cada uno detecta una cosa distinta y cada uno se responde con una herramienta distinta. Este artículo recorre los cinco con el caso que los origina: consultar archivos de genealogía y registros públicos, sitio a sitio, sin una API de por medio. Al final tienes una tabla de decisión, dos grabaciones de terminal y un script para medir qué ve una página de tu propio navegador.

1. Cinco defensas anti-bot, no una

robots.txt no protege nada. Es una petición de cortesía: el servidor pide a los rastreadores que no entren en ciertas rutas y confía en que le hagan caso. La propia Wikipedia lo dice sin rodeos: el protocolo es puramente consultivo y no puede imponer nada; un robot malicioso puede incluso leer el fichero para encontrar justo las rutas que le interesan.

Por eso los sitios que de verdad quieren proteger sus datos añaden capas. Y cada capa se distingue por lo que devuelve:

Lo que ves#Salida
403 sin User-Agent o sin Referer0curl -A -e -b -c
HTML vacío o «activa JavaScript»1Headless
Reto que no termina en headless2Chrome + perfil
403 o CAPTCHA con Playwright3Chrome + CDP
Tu navegador también está bloqueado4Otra fuente

Escalera de cinco niveles de protección anti-bot, del HTTP plano al humano bloqueado, con la respuesta técnica en cada uno

Cada nivel se detecta por una señal distinta; por eso la herramienta también cambia.

El orden importa. Casi todos los intentos fallidos que he visto consisten en saltarse un peldaño: meter Playwright donde bastaba curl, o pelearse con un CAPTCHA cuando el problema era que el navegador se identificaba como headless. Y subir un nivel cuesta más: un curl es gratis; un navegador con interfaz y un perfil persistente ya necesita una máquina con escritorio.

Esto no es una licencia para hacer scraping de lo que te apetezca. Antes de automatizar, mira los términos del sitio, la carga que le vas a meter y la normativa que te aplica. En la UE no existe un «fair use» general: la Directiva (UE) 2019/790 permite la minería de textos y datos con fines de investigación científica, y para otros fines solo si el titular no la ha reservado expresamente. Los datos personales de personas vivas siguen bajo el RGPD. Un 403 no es un permiso.

2. Nivel 0: curl con User-Agent, Referer y cookies

El nivel más bajo no tiene protección seria, solo comprobaciones de superficie. Y las comprobaciones cambian de un sitio a otro: uno mira el User-Agent, otro exige Referer solo en las imágenes, otro comprueba que traigas la cookie de sesión.

curl cubre los tres casos:

1
2
3
4
5
6
7
8
# 1. Guardar las cookies que devuelve el servidor
curl -c cookies.txt https://ejemplo.com

# 2. Enviar las cookies guardadas
curl -b cookies.txt https://ejemplo.com

# 3. Enviar y volver a guardar: mantiene la sesión entre peticiones
curl -b cookies.txt -c cookies.txt https://ejemplo.com

-c escribe el fichero de cookies y -b lo lee. Si usas los dos a la vez, cada respuesta actualiza el fichero y la sesión sobrevive al proceso. Para el User-Agent está -A; para el Referer, -e:

1
2
3
curl -A "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/151.0.0.0 Safari/537.36" \
     -e https://ejemplo.com/ \
     https://ejemplo.com/datos
Grabación de terminal

Tres peticiones al mismo servicio: sin identificarse, con User-Agent y Referer, y con una cookie de sesión. El servidor devuelve exactamente lo que le has dado.

Si el sitio sigue rechazando curl con las cabeceras correctas, probablemente esté mirando algo más profundo: la huella TLS. Los navegadores usan combinaciones fijas de cifrados y extensiones, y el resumen de esa combinación —JA3 o JA4— identifica al cliente aunque el User-Agent diga otra cosa. curl_cffi es un cliente de Python que imita esa huella:

1
2
3
4
import curl_cffi

r = curl_cffi.get("https://ejemplo.com/datos", impersonate="chrome")
print(r.status_code)

En la práctica no suele hacer falta llegar aquí. Cuando un sitio comprueba la huella TLS, casi siempre pide también JavaScript, y eso ya es el nivel siguiente.

3. Nivel 1: sin JavaScript no hay página

Aquí hay dos motivos que se confunden todo el tiempo. El primero es un guardián de verdad. El segundo es un sitio construido entero en JavaScript: formularios que se montan al cargar, visores que llenan la caché al hacer clic, catálogos que cargan el árbol al desplegarlo. No hay nada hostil, simplemente no hay HTML que curl pueda leer.

Los dos guardianes que me he encontrado en este nivel son Anubis y las detecciones JavaScript de Cloudflare.

Anubis es software libre y añade una prueba de trabajo antes de dejar pasar. El navegador concatena un número al reto, calcula SHA-256 y busca un resultado que empiece por una cantidad configurable de ceros hexadecimales; por defecto, cinco. Si acierta, recibe una cookie JWT firmada y válida durante un rato. Sin JavaScript no hay forma de resolverlo. Lo creó Xe Iaso después de que un rastreador de Amazon tumbara su servidor de Git sin respetar robots.txt; LWN lo contó cuando el proyecto empezó a extenderse por las forjas y los proyectos de software libre. Tiene su gracia que la propia documentación de Anubis esté detrás de Anubis.

Cloudflare, por su parte, inyecta un fragmento invisible de JavaScript Detections solo en las peticiones de páginas HTML, no en las llamadas AJAX. Su documentación dice explícitamente que detecta navegadores headless y otras herramientas de automatización. Si el sitio está configurado para ello, un navegador sin ventana no pasa.

La respuesta a este nivel es la más sencilla de todas: usa un navegador. Playwright lo controla desde Python, JavaScript, Java o .NET, y en muchos sitios basta con el modo headless:

1
2
3
4
5
6
7
8
9
from playwright.sync_api import sync_playwright

with sync_playwright() as pw:
    browser = pw.chromium.launch()          # headless por defecto
    page = browser.new_page()
    page.goto("https://ejemplo.com", wait_until="domcontentloaded")
    page.wait_for_selector("main")
    print(page.inner_text("body")[:500])
    browser.close()

Playwright no lanza el mismo binario en los dos modos. Para uso headed descarga un Chromium normal; para headless usa un chromium-headless-shell aparte, más pequeño y sin las piezas de interfaz. Es una decisión de ingeniería razonable y, a la vez, una de las señales que veremos en el nivel 2.

El navegador ya es una plataforma completa: si te interesa hasta dónde llega JavaScript cuando le das una máquina entera, el 486DX2-66 emulado en una pestaña es la demostración más exagerada que conozco.

4. Nivel 2: el headless se delata

Cloudflare lo dice sin ambigüedad en su documentación sobre el bot score: las detecciones JavaScript atrapan navegadores headless y otras herramientas de automatización. Turnstile e Imperva hacen lo mismo con más o menos piezas. La pregunta no es si el navegador es headless, sino cuántas señales lo delatan a la vez.

Estas son las que importan:

  • Identidad declarada. El User-Agent de Chrome headless contiene HeadlessChrome. Además, Chromium pone navigator.webdriver a true cuando arranca con --headless, con --enable-automation o con --remote-debugging-pipe, que es el canal que usa Playwright para hablar con el navegador. El argumento --disable-blink-features=AutomationControlled oculta la propiedad, pero no las demás señales; la marca está en el código de Blink.
  • Entorno de renderizado. Un headless no tiene GPU real. El tamaño de pantalla, la profundidad de color y el ratio de píxeles son de fábrica; las fuentes cambian; las huellas de canvas y AudioContext salen distintas. En mi equipo, el mismo Chromium informa de SwiftShader en modo headless y de una Radeon 780M con ventana.
  • Objetos que faltan. window.chrome y la lista de plugins estaban vacíos en el Chrome headless antiguo. Desde Chrome 112 el modo headless y el headed comparten binario, pero desde 132 el modo antiguo sobrevive como chrome-headless-shell, que es justo el que usa Playwright por defecto. Ahí siguen faltando.
  • Geometría. En headless outerWidth es igual a innerWidth, porque no hay marco de ventana. En una ventana real no coinciden.
  • Comportamiento. No hay movimiento de ratón, no hay scroll, los formularios se rellenan de golpe y la página nunca pide un favicon ni hace prefetch.

Tabla de señales medidas en headless, headed y por CDP: User-Agent, navigator.webdriver, window.chrome, plugins, GPU y outerWidth

Medido en este equipo con Chrome 151 lanzado por Playwright y Brave 156 lanzado desde la shell. La columna de CDP es la que sorprende: webdriver vuelve a false.

La respuesta a este nivel es un navegador con ventana, un perfil persistente y, si hace falta, el Chrome de verdad en lugar del Chromium que trae Playwright:

1
2
3
4
5
6
7
8
9
from playwright.sync_api import sync_playwright

with sync_playwright() as pw:
    context = pw.chromium.launch_persistent_context(
        user_data_dir=".browser-profiles/ejemplo",                # 1
        channel="chrome",                                         # 2
        headless=False,                                           # 3
        args=["--disable-blink-features=AutomationControlled"],   # 4
    )
  1. El perfil guarda cookies, almacenamiento local y la autorización del reto.
  2. channel="chrome" usa el Chrome instalado en el sistema, no el Chromium de Playwright.
  3. Con ventana. Necesita un escritorio o un servidor X.
  4. Oculta navigator.webdriver, aunque no sea la única señal.

El perfil es la pieza que casi nadie explica bien. Cuando un humano resuelve el reto una vez, Cloudflare le da una cookie cf_clearance. Esa cookie está vinculada al visitante y al dispositivo que la obtuvo, y su documentación lo dice: copiarla a un contexto nuevo no sirve, porque la huella del navegador que la presenta tiene que coincidir con la que la obtuvo. En la misma web y el mismo día, un contexto limpio recibe un reto irresoluble; el perfil reutilizado no recibe ninguno.

Un perfil de navegador es una credencial. Contiene cookies de sesión, localStorage y autorizaciones que pueden valer dinero. No lo metas en Git, no lo compartas y no lo dejes en una carpeta pública. Si el script cierra el contexto al terminar, cierra también la sesión: usa page.close() y deja vivo el contexto.

Hay dos productos que implementan este nivel con nombres propios: Turnstile, que sustituye el CAPTCHA por una comprobación invisible, e Imperva, que añade su propia batería. Pero el producto no decide el nivel: lo decide la configuración del sitio. He visto Turnstile pasar con un navegador headed en un sitio y bloquearlo en otro.

5. Nivel 3: lanza Chrome tú y conecta Playwright por CDP

Este es el peldaño que nadie espera. Incluso un navegador con ventana, un perfil ya autorizado y AutomationControlled desactivado puede recibir un 403 sin que el reto llegue a aparecer. En el caso que originó este artículo, el mismo perfil daba resultados distintos según quién arrancara el navegador:

Chrome arrancado porEstado HTTPDetalle
Playwright, headed, AutomationControlled desactivado, perfil ya resuelto por un humano403Cuerpo vacío, ni siquiera ofrece el reto
La shell, con --remote-debugging-port, y Playwright conectado después200Contenido y siete cookies, incluida la de clearance

Todo era igual salvo el lanzador. El sitio detectaba el método de arranque antes de mostrar el reto.

No sé qué señal exacta usa ese sitio. Playwright arranca Chrome con una lista de switches propia: --enable-automation, --remote-debugging-pipe, --disable-extensions, --disable-field-trial-config, una lista larga de --disable-features y --use-mock-keychain. Una diferencia conocida: Chromium pone navigator.webdriver con --remote-debugging-pipe, pero con --remote-debugging-port solo lo pone cuando el puerto es 0. En el 9222 se queda en false sin necesidad de ningún truco extra.

La conclusión es directa: lanza Chrome tú y deja que Playwright se conecte.

1
2
3
4
5
6
7
8
9
10
# macOS
"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" \
  --remote-debugging-port=9222 \
  --user-data-dir="$PWD/.browser-profiles/ejemplo" \
  --no-first-run --no-default-browser-check &

# Linux (Chrome, Chromium o Brave)
google-chrome --remote-debugging-port=9222 \
  --user-data-dir="$PWD/.browser-profiles/ejemplo" \
  --no-first-run --no-default-browser-check &

Resuelve el reto una vez en esa ventana, a mano, sin navegar mientras se ejecuta. Después conecta Playwright:

1
2
3
4
5
6
7
8
9
10
11
from playwright.sync_api import sync_playwright

url = "https://ejemplo.com"

with sync_playwright() as pw:
    browser = pw.chromium.connect_over_cdp("http://127.0.0.1:9222")
    context = browser.contexts[0]        # 1
    page = context.new_page()            # 2
    page.goto(url)
    print(page.inner_text("body")[:2000])
    page.close()                         # 3
  1. El contexto que ya existe, con el perfil autorizado.
  2. Una pestaña nueva por consulta.
  3. Cierra la pestaña, nunca el contexto.

La documentación de connect_over_cdp avisa de que la conexión tiene menos fidelidad que el protocolo nativo de Playwright: algunos eventos no llegan. Por eso el ejemplo lee el texto y lo procesa en Python en vez de interceptar respuestas.

Comparación entre Playwright lanzando el navegador, que recibe 403, y Chrome lanzado desde la shell con conexión por CDP, que recibe 200

En el caso que originó este artículo, mismo binario y mismo perfil. La diferencia es quién pulsó el interruptor.

Grabación de terminal

Playwright lanza el navegador y la página ve webdriver: true. Lanzado desde la shell y conectado por CDP, webdriver: false; el resto de señales sigue ahí.

Hay dos trampas que cuestan tiempo y no avisan.

La primera es silenciosa. Desde Chrome 136, el puerto de depuración se ignora en el perfil por defecto. Chrome for Developers lo explica: los switches ya no se respetan si intentas depurar el directorio de datos estándar y tienen que ir acompañados de --user-data-dir apuntando a otro directorio. No hay error en la ventana ni aviso en la consola: Chrome arranca normal y el puerto simplemente no existe. El síntoma es que curl http://127.0.0.1:9222/json/version no conecta mientras ps muestra el argumento en la línea de comandos.

La segunda también es muda. Si lanzas Chrome mientras otra instancia usa el mismo perfil, el arranque se delega a la instancia que ya está corriendo y el puerto nunca se abre. Cierra Chrome del todo antes.

Antes de culpar a Playwright, comprueba que el puente existe:

1
curl -s http://127.0.0.1:9222/json/version | jq -r .Browser

Si esto no devuelve un nombre de navegador, el problema está en el arranque, no en la conexión.

6. Nivel 4: cuando tu navegador tampoco pasa

No todas las webs hostiles se abren manejando el navegador a mano. Una detectó mi Chrome de uso diario, el de todos los días, con su perfil y su historial. No había CAPTCHA que resolver ni autorización que ganar: la página simplemente no estaba. Encontré los datos en un espejo.

Los muros de pago son otro caso, y se confunden a menudo con la detección de bots. Un sitio que oculta campos a las cuentas gratuitas no está detectando nada: no hay truco de navegador que revele lo que el servidor no envía. Si la respuesta depende de una suscripción, la solución es pagarla o buscar otra fuente, no cambiar el User-Agent.

7. Límite de peticiones: el bloqueo que cruza todos los niveles

El límite de peticiones es independiente de todo lo anterior. En un sitio, después de media docena de peticiones rápidas, dejó de funcionar todo a la vez: curl, Playwright y mi navegador de siempre recibían la misma negativa. Habían bloqueado mi IP, no al cliente.

Conecté por VPN, obtuve otra IP y el sitio volvió a responder de inmediato. Para las ejecuciones siguientes me limité con una pausa entre peticiones y no volví a tocarlo.

1
2
3
4
import random
import time

time.sleep(random.uniform(1.5, 3.5))

Otro sitio limita el número de búsquedas diarias por cuenta, sin importar el cliente. Ahí no hay técnica que valga: una consulta que no se ha podido hacer no es una consulta con resultado negativo. Anótala como pendiente, no como «no existe».

Esto es lo mismo que ocurre cuando el bloqueo es de red y no de aplicación: en el post sobre DNS contra los bloqueos de LaLiga el filtro está en la resolución, no en la web. Aquí está en la IP. La lección se repite: identifica la capa antes de elegir la herramienta.

Si vas a hacer muchas peticiones, no optimices el sigilo: optimiza la educación. Una petición cada dos o tres segundos, concurrencia uno, respetar Retry-After y cachear lo que ya tienes evita más bloqueos que cualquier plugin.

8. Runtime.enable: la fuga de CDP que este mapa no cubre

Hay una detección más profunda que el lanzador y que el User-Agent: la de que hay un cliente CDP al otro lado, da igual qué binario sea y da igual quién lo arranque.

DataDome publicó en 2024 cómo detectarla. La idea es esta: las bibliotecas de automatización envían Runtime.enable para recibir eventos del navegador. Ese comando hace que Chromium emita Runtime.consoleAPICalled, y para eso tiene que serializar objetos. Una página puede provocar esa serialización y medir el tiempo: si el objeto se serializa cuando no debería, hay un cliente CDP conectado. Son unas cinco líneas de JavaScript y funciona con frameworks que intentan pasar desapercibidos.

Flujo de la fuga de Runtime.enable: Playwright activa el dominio Runtime, Chromium serializa el objeto y el detector de la página lo mide

La fuga no está en el binario ni en el perfil: está en el canal que usa la herramienta para hablar con el navegador.

Rebrowser comprobó el efecto: al desactivar Runtime.enable en Playwright y Puppeteer, el CAPTCHA de sitios protegidos con Turnstile y DataDome desaparecía con las mismas condiciones de IP y de equipo. Su parche crea contextos aislados con identificadores que la página no conoce y ejecuta allí el código, o llama a Runtime.enable y lo desactiva de inmediato para capturar el identificador sin dejar la puerta abierta.

Patchright lleva esa idea a un fork de Playwright que se usa como reemplazo directo:

1
from patchright.sync_api import sync_playwright

Sus parches principales son tres: evita Runtime.enable ejecutando JavaScript en contextos aislados, elimina --enable-automation de los argumentos por defecto y añade --disable-blink-features=AutomationControlled. A cambio, desactiva la API de consola y solo funciona con navegadores basados en Chromium. No es magia: es una carrera.

FugaQué revelaMitigación
Runtime.enableQue hay un cliente CDP conectadoContextos aislados o enable/disable inmediato
--enable-automationQue el navegador está automatizadoQuitarlo de los argumentos
navigator.webdriverQue el documento está controladoAutomationControlled o arranque por CDP
Perfil sin historialQue la sesión es nuevaPerfil persistente y uso real

9. ¿Te delata tu Playwright? Mídelo con un script

Necesitas Python 3.9 o superior, Playwright y un navegador instalado. En Linux y macOS:

1
2
3
4
5
python3 -m venv .venv
source .venv/bin/activate
pip install playwright
playwright install chromium
playwright install chrome   # opcional: el Chrome de verdad, para channel="chrome"

En Windows, el entorno se activa con .venv\Scripts\activate. Para el modo headed hace falta un escritorio; en un servidor sin pantalla, xvfb-run resuelve la papeleta. Si además lo metes en un contenedor, prepárate: las imágenes con Chrome engordan rápido, y dive te dice exactamente qué capa se lleva el espacio.

El script que mide las señales de la sección 4 cabe en una pantalla:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import sys
from playwright.sync_api import sync_playwright

JS = """() => {
  const gl = document.createElement('canvas').getContext('webgl');
  const ext = gl && gl.getExtension('WEBGL_debug_renderer_info');
  return {
    userAgent: navigator.userAgent,
    webdriver: navigator.webdriver,
    chrome: typeof window.chrome,
    plugins: navigator.plugins.length,
    screen: `${screen.width}x${screen.height}`,
    window: `${outerWidth}x${innerWidth}`,
    gpu: ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : null,
  };
}"""

headed = "--headed" in sys.argv
with sync_playwright() as pw:
    browser = pw.chromium.launch(headless=not headed)
    page = browser.new_page()
    page.goto("https://example.com")
    for key, value in page.evaluate(JS).items():
        print(f"{key:10} {value}")
    browser.close()

En mi equipo, python3 tells.py devuelve esto:

1
2
3
4
5
6
7
userAgent  Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/151.0.7922.34 Safari/537.36
webdriver  True
chrome     undefined
plugins    0
screen     1280x720
window     1280x1280
gpu        ANGLE (Google, Vulkan 1.3.0 (SwiftShader Device (Subzero) (0x0000C0DE)), SwiftShader driver)

Y con python3 tells.py --headed:

1
2
3
4
5
6
7
userAgent  Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36
webdriver  True
chrome     object
plugins    5
screen     1280x720
window     1288x1280
gpu        ANGLE (AMD, AMD Radeon 780M Graphics (radeonsi phoenix ACO), OpenGL ES 3.2)

Dos cosas llaman la atención. La primera: webdriver sigue en true incluso con ventana, porque Playwright arranca con --enable-automation y --remote-debugging-pipe. La segunda: el resto de señales mejora mucho. Hay window.chrome, hay plugins, la GPU es real y la ventana tiene marco. Si quieres ver el cambio completo, arranca el navegador desde la shell y conéctate por CDP: webdriver pasa a false y la GPU sigue siendo la misma.

Para probar tu propia configuración contra un detector público, bot.sannysoft.com sigue siendo la página de referencia: muestra el User-Agent, navigator.webdriver, window.chrome, los plugins, los idiomas, el vendor y el renderer de WebGL en una sola tabla. No es la prueba definitiva —sus comprobaciones son antiguas y los detectores comerciales miran mucho más—, pero es un buen punto de partida para saber si tu navegador se delata.

10. Qué defensa toca en cada caso

PreguntaSi la respuesta es síSi es no
¿El sitio permite el acceso en sus términos?SigueBusca otra fuente
¿curl con -A y -e devuelve el HTML?Nivel 0: usa curlNivel 1
¿Un Playwright headless carga la página?Nivel 1: headlessNivel 2
¿Un Chrome headed con perfil pasa el reto?Nivel 2: headed y perfilNivel 3
¿El mismo perfil funciona si lanzas Chrome desde la shell?Nivel 3: CDPNivel 4
¿Falla también tu navegador de siempre?Nivel 4: otra fuenteNivel 3.5: CDP (sección 8)
¿Todo falla a la vez tras una ráfaga, también curl?Límite de peticiones o IP: baja el ritmoRevisa el nivel anterior

La conclusión práctica es que el sigilo se compra por capas y cada capa tiene un precio: complejidad, una máquina con escritorio, un perfil que cuidar, un fork que mantener. El objetivo no es ganar siempre. Es saber en qué peldaño estás, cuánto cuesta subir uno más y cuándo la respuesta sensata es bajarse de la escalera.

11. Enlaces y vídeos de interés

11.1 Artículos

11.2 Vídeos

Cómo arrancar Chrome con el puerto de depuración y conectar Playwright a esa instancia. Es exactamente el flujo del nivel 3.

SeleniumBase usa connect_over_cdp para conectar Playwright a un navegador con modo stealth. Una implementación práctica de la misma idea.

Un recorrido por una biblioteca de stealth para Playwright: qué parchea y qué señales quedan. Útil como contraste con el enfoque manual.

Esta entrada está licenciada bajo CC BY 4.0 por el autor.