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.
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 Referer | 0 | curl -A -e -b -c |
| HTML vacío o «activa JavaScript» | 1 | Headless |
| Reto que no termina en headless | 2 | Chrome + perfil |
| 403 o CAPTCHA con Playwright | 3 | Chrome + CDP |
| Tu navegador también está bloqueado | 4 | Otra fuente |
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
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-Agentde Chrome headless contieneHeadlessChrome. Además, Chromium ponenavigator.webdriveratruecuando arranca con--headless, con--enable-automationo con--remote-debugging-pipe, que es el canal que usa Playwright para hablar con el navegador. El argumento--disable-blink-features=AutomationControlledoculta 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
SwiftShaderen modo headless y de unaRadeon 780Mcon ventana. - Objetos que faltan.
window.chromey 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 comochrome-headless-shell, que es justo el que usa Playwright por defecto. Ahí siguen faltando. - Geometría. En headless
outerWidthes igual ainnerWidth, 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.
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
)
- El perfil guarda cookies, almacenamiento local y la autorización del reto.
channel="chrome"usa el Chrome instalado en el sistema, no el Chromium de Playwright.- Con ventana. Necesita un escritorio o un servidor X.
- 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,
localStoragey 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: usapage.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 por | Estado HTTP | Detalle |
|---|---|---|
Playwright, headed, AutomationControlled desactivado, perfil ya resuelto por un humano | 403 | Cuerpo vacío, ni siquiera ofrece el reto |
La shell, con --remote-debugging-port, y Playwright conectado después | 200 | Contenido 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
- El contexto que ya existe, con el perfil autorizado.
- Una pestaña nueva por consulta.
- 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.
En el caso que originó este artículo, mismo binario y mismo perfil. La diferencia es quién pulsó el interruptor.
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:
1curl -s http://127.0.0.1:9222/json/version | jq -r .BrowserSi 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-Aftery 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.
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.
| Fuga | Qué revela | Mitigación |
|---|---|---|
Runtime.enable | Que hay un cliente CDP conectado | Contextos aislados o enable/disable inmediato |
--enable-automation | Que el navegador está automatizado | Quitarlo de los argumentos |
navigator.webdriver | Que el documento está controlado | AutomationControlled o arranque por CDP |
| Perfil sin historial | Que la sesión es nueva | Perfil 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
| Pregunta | Si la respuesta es sí | Si es no |
|---|---|---|
| ¿El sitio permite el acceso en sus términos? | Sigue | Busca otra fuente |
¿curl con -A y -e devuelve el HTML? | Nivel 0: usa curl | Nivel 1 |
| ¿Un Playwright headless carga la página? | Nivel 1: headless | Nivel 2 |
| ¿Un Chrome headed con perfil pasa el reto? | Nivel 2: headed y perfil | Nivel 3 |
| ¿El mismo perfil funciona si lanzas Chrome desde la shell? | Nivel 3: CDP | Nivel 4 |
| ¿Falla también tu navegador de siempre? | Nivel 4: otra fuente | Nivel 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 ritmo | Revisa 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
- The Lab #57: Improving your Playwright scraper and avoid CDP detection — el complemento perfecto a la sección 8: qué es la detección CDP y cómo mitigarla.
- Three Chromium builds against common bot checks — comparación medida de Chromium, Chrome y Patchright en headless y con ventana.
- Scrapling: Browser fetching with StealthyFetcher — una biblioteca que empaqueta varias de estas ideas, incluida la conexión por CDP.
- How Anubis works — los detalles de la prueba de trabajo, el JWT y las políticas de bots.
- Antibot — la página de pruebas para medir tus propias señales antes de culpar al sitio.
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.
