Cómo resolver CAPTCHA en la automatización de navegadores con el Agente Hermes y CapSolver

Cuando tu agente de IA navega por la web por ti, los CAPTCHA son el obstáculo número uno. Las páginas protegidas bloquean al agente, los formularios se niegan a enviar y las tareas se detienen esperando intervención humana.

Hermes Agent de Nous Research es un agente de IA automejorante que funciona en cualquier lugar — desde un VPS de $5 hasta un clúster de GPU — y te alcanza en cada canal que ya usas: Telegram, Discord, Slack, WhatsApp, Signal y correo electrónico. También puede controlar un navegador para navegar páginas, hacer clic en botones, completar formularios y extraer datos en tu nombre. Pero como cualquier agente que controla un navegador, se atasca con los CAPTCHA.

CapSolver cambia esto por completo. Al cargar la extensión de CapSolver en el navegador al que se conecta Hermes, los CAPTCHA se resuelven automáticamente e invisiblemente en segundo plano. No se necesita código. No se requieren llamadas a API desde tu parte. No se necesitan ejercicios de ingeniería de prompts.

Lo mejor de todo es que ni siquiera necesitas mencionar los CAPTCHA al agente. Solo le dices que espere un momento antes de enviar — y cuando haga clic en Enviar, el CAPTCHA ya estará resuelto.

¿Qué es Hermes Agent?

Hermes Agent es un agente de IA autónomo de código abierto desarrollado por Nous Research. Está diseñado alrededor de tres principios: memoria persistente (recuerda quién eres y tus proyectos entre sesiones), creación autónoma de habilidades (aprende procedimientos a partir de la experiencia y los reproduce la próxima vez), e flexibilidad de infraestructura (puedes ejecutarlo en un VPS pequeño, un contenedor Docker, un entorno serverless, o en tu propio equipo con GPU).

Características clave

• Puerta de entrada multi-canal: Habla con tu agente desde Telegram, Discord, Slack, WhatsApp, Signal, correo electrónico o su propia interfaz de terminal
• Modelo a tu elección: OpenRouter (200+ modelos), Nous Portal, NVIDIA NIM, Z.AI, tu propio endpoint — cambia con hermes model
• Memoria de sesión cruzada: Búsqueda de sesión FTS5 + resumen por LLM significa que el agente recuerda lo que hablaste la semana pasada
• Sistema de habilidades: Memoria procedural que el agente construye por sí mismo, compatible con el estándar agentskills.io
• Siete backends de terminal: Local, Docker, SSH, Singularity, Modal, Daytona, Vercel Sandbox
• Herramienta de navegador integrada: Controla un Chromium real mediante Playwright + Protocolo DevTools

La herramienta del navegador

Hermes puede controlar un navegador Chromium para realizar trabajo real — navegar, leer el DOM, hacer clic, escribir, tomar capturas de pantalla, extraer datos. Su capa de herramienta del navegador es poco común en un aspecto específico: en lugar de obligarte a usar un solo backend, Hermes soporta cinco proveedores de navegador intercambiables:

Los proveedores en la nube no pueden cargar extensiones — no controlas el navegador remoto. Camoufox está basado en Firefox y no ejecutará una extensión de Chrome MV3. El punto de integración limpio es el quinto: CDP attach, donde Hermes se conecta a un Chromium tú lanzaste separadamente. Ese es el lugar donde entra CapSolver.

Este es un modelo diferente al de herramientas como OpenClaw (que lanza su propio Chromium y acepta un arreglo browser.extensions) o Crawlee (donde controlas las banderas de lanzamiento de Playwright). Con Hermes, traes tu propio Chrome con la extensión precargada, y Hermes se conecta a él a través del protocolo DevTools.

¿Qué es CapSolver?

CapSolver es un servicio líder para resolver CAPTCHA que ofrece soluciones impulsadas por IA para superar los desafíos de CAPTCHA modernos. Con soporte para cada tipo de CAPTCHA importante y tiempos de respuesta rápidos, CapSolver se integra sin problemas en flujos automatizados — ya sea que estés controlando un navegador mediante Playwright, llamando a su API directamente, o, como en esta guía, ejecutando su extensión de Chrome dentro de una sesión del navegador del agente.

¿Por qué esta integración es diferente?

La mayoría de las integraciones para resolver CAPTCHA requieren que escribas código — crear llamadas a API, consultar resultados, inyectar tokens en campos ocultos de formularios. Así funciona con herramientas como Crawlee, Puppeteer o Playwright.

Hermes + CapSolver es fundamentalmente diferente:

La clave está en que: La extensión de CapSolver se ejecuta dentro del navegador conectado. Hermes se conecta a ese navegador a través del CDP y lo controla normalmente. Cuando el agente navega a una página con un CAPTCHA, la extensión — ejecutándose en el mismo Chrome, completamente invisible para el agente — detecta el widget, llama a la API de CapSolver y inyecta el token de solución en la página. Para cuando el agente haga clic en Enviar, el formulario ya lleva un token válido.

Solo necesitas darle tiempo. En lugar de decirle al agente "resuelve el CAPTCHA", simplemente dí:

"Ve a esa página, espera 60 segundos, luego haz clic en Enviar."

Eso es todo. El agente no necesita saber que CapSolver existe.

Requisitos previos

Antes de configurar la integración, asegúrate de tener:

1. Hermes Agent instalado y el gateway en ejecución (instrucciones de instalación)
2. Una cuenta de CapSolver con clave de API (regístrate aquí)
3. Chromium o Chrome para pruebas (ver nota importante a continuación)

Importante: Necesitas Chromium, no Google Chrome

Google Chrome 137+ (lanzado a mediados de 2025) eliminó silenciosamente el soporte para --load-extension en las versiones de marca. Esto significa que las extensiones de Chrome no pueden cargarse en sesiones automatizadas usando Google Chrome estándar. No hay error — el indicador simplemente se ignora.

Esto afecta a Google Chrome y Microsoft Edge. Debes usar una de estas alternativas:

Cómo instalar Chrome para pruebas:

# Opción 1: A través de Playwright (recomendado — Hermes ya usa Playwright internamente)
npx playwright install chromium

# La ubicación del binario será algo como:
# ~/.cache/ms-playwright/chromium-XXXX/chrome-linux64/chrome           (Linux)
# ~/Library/Caches/ms-playwright/chromium-XXXX/chrome-mac/Chromium.app/Contents/MacOS/Chromium  (macOS)

# Opción 2: A través de descarga directa de Chrome para pruebas
# Visita: https://googlechromelabs.github.io/chrome-for-testing/
# Descarga la versión que corresponda a tu sistema operativo

Después de la instalación, anota la ruta completa al binario — la necesitarás en el siguiente paso.

Configuración paso a paso

La integración tiene dos componentes que trabajan juntos:

1. Un proceso de Chrome separado que lanzas con la extensión de CapSolver precargada y CDP expuesto en un puerto conocido (usaremos 9222).
2. Un pequeño cambio en el config.yaml de Hermes para que se conecte a ese puerto CDP en lugar de iniciar su propio navegador.

Eso es todo — sin código, sin parchear Hermes.

Paso 1: Descarga la extensión de Chrome de CapSolver

Descarga la extensión de Chrome de CapSolver y extráela a una ubicación estable:

1. Ve a las versiones de la extensión de CapSolver en GitHub
2. Descarga la última CapSolver.Browser.Extension-chrome-vX.X.X.zip
3. Extrae el zip:

mkdir -p ~/.hermes/capsolver-extension
unzip CapSolver.Browser.Extension-chrome-v*.zip -d ~/.hermes/capsolver-extension/

4. Verifica que la extracción funcionó:

ls ~/.hermes/capsolver-extension/manifest.json

Deberías ver manifest.json — esto confirma que la extensión está en el lugar correcto.

Consejo sobre rutas: Usa una ruta absoluta y resuelta (no ~) cuando pases --load-extension=... a Chrome. Algunas construcciones de Chrome MV3 tienen casos límite donde los trabajadores de extensión no se registran a través de enlaces simbólicos en directorios de usuario personalizados. Si enlazas simbólicamente la extensión desde otra ubicación, usa readlink -f para resolver la ruta real y úsala.

Paso 2: Establece tu clave de API de CapSolver

Abre el archivo de configuración de la extensión en ~/.hermes/capsolver-extension/assets/config.js y reemplaza el valor de apiKey con el tuyo:

export const defaultConfig = {
  apiKey: 'CAP-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',  // ← aquí tu clave
  useCapsolver: true,
  enabledForRecaptcha: true,
  enabledForRecaptchaV3: true,
  // ... resto de la configuración
};

Puedes obtener tu clave de API desde tu panel de CapSolver.

Paso 3: Lanza Chrome con la extensión y CDP activado

Este es el paso clave. Lanzamos Chrome una vez, separadamente de Hermes, con tres indicadores cruciales:

• --remote-debugging-port=9222 — expone el protocolo DevTools para que Hermes se conecte
• --load-extension=... — carga previamente la extensión de CapSolver
• --user-data-dir=... — usa un perfil dedicado para no colisionar con tu Chrome personal

Hermes tiene una convención integrada para el directorio de datos de usuario: ~/.hermes/chrome-debug. Usar esa ruta significa que el comando /browser connect de Hermes también "funciona" sin necesidad de flags adicionales.

Opción A: Lanzamiento manual único (bueno para pruebas rápidas)

/path/to/chrome-for-testing/chrome \
  --remote-debugging-port=9222 \
  --remote-debugging-address=127.0.0.1 \
  --user-data-dir="$HOME/.hermes/chrome-debug" \
  --load-extension="$HOME/.hermes/capsolver-extension" \
  --disable-extensions-except="$HOME/.hermes/capsolver-extension" \
  --no-first-run \
  --no-default-browser-check \
  --no-sandbox

Reemplaza /path/to/chrome-for-testing/chrome con tu binario real, por ejemplo ~/.cache/ms-playwright/chromium-1200/chrome-linux64/chrome.

Servidores en modo cabeza: Si lo ejecutas en un servidor Linux sin una pantalla física (un VPS, EC2, etc.), consulta la sección Mejores prácticas a continuación para la configuración de Xvfb. El subsistema de extensiones de Chrome requiere un contexto de visualización.

Opción B: Proceso en segundo plano persistente (recomendado para producción)

Para cualquier configuración que dure más que una sola prueba, envuelve el lanzamiento en un pequeño script de shell para que puedas mantener Chrome en segundo plano, reiniciarlo limpiamente y supervisarlo con cualquier gestor de procesos que ya uses (systemd, supervisor, runit, OpenRC, Docker, etc.).

Guárdalo como ~/.hermes/chrome-debug.sh y hazlo ejecutable con chmod +x:

#!/usr/bin/env bash
# ~/.hermes/chrome-debug.sh
# Lanza Chrome para pruebas con la extensión de CapSolver precargada
# y CDP expuesto en 127.0.0.1:9222.

CHROME_BIN="$HOME/.cache/ms-playwright/chromium-1200/chrome-linux64/chrome"
EXT_DIR="$HOME/.hermes/capsolver-extension"
USER_DATA_DIR="$HOME/.hermes/chrome-debug"

export DISPLAY=:99   # para servidores en modo cabeza — ver sección de Mejores prácticas

exec "$CHROME_BIN" \
  --remote-debugging-port=9222 \
  --remote-debugging-address=127.0.0.1 \
  --user-data-dir="$USER_DATA_DIR" \
  --load-extension="$EXT_DIR" \
  --disable-extensions-except="$EXT_DIR" \
  --no-first-run \
  --no-default-browser-check \
  --no-sandbox \
  --disable-dev-shm-usage \
  --disable-features=Translate

El lanzamiento más simple es simplemente:

nohup ~/.hermes/chrome-debug.sh > /tmp/chrome-debug.log 2>&1 &

Para producción, supervisa el script con el gestor de procesos que prefieras. Una unidad systemd mínima en ~/.config/systemd/user/chrome-debug.service:

[Unit]
Description=Chrome equipado con CapSolver para Hermes Agent
After=network.target

[Service]
ExecStart=%h/.hermes/chrome-debug.sh
Restart=always
RestartSec=5

[Install]
WantedBy=default.target

Luego:

systemctl --user daemon-reload
systemctl --user enable --now chrome-debug

Cualquier configuración equivalente (programa de supervisord, servicio de runit, contenedor Docker, etc.) funciona de manera idéntica — la integración solo se preocupa por que algo mantenga ejecutándose chrome-debug.sh.

Paso 4: Dile a Hermes que se conecte a través de CDP

Edita tu configuración de Hermes en ~/.hermes/config.yaml. Encuentra la sección browser: (normalmente solo tiene inactivity_timeout) y agrega un cdp_url:

browser:
  inactivity_timeout: 120
  cdp_url: http://127.0.0.1:9222

Esa única línea le dice a la herramienta browser_cdp de Hermes que redirija todas las operaciones del navegador al Chrome que lanzamos en el Paso 3, en lugar de iniciar su propio.

Reversibilidad: Esta es la única modificación en Hermes. Para revertir, elimina la línea cdp_url. Hermes regresa al proveedor de navegador predeterminado que usaba (Browserbase, Browser Use, etc.) sin efectos secundarios.

Paso 5: Reinicia Hermes

Si Hermes ya está en ejecución, reinícielo para que tome el nuevo cdp_url:

# Ejecutando directamente (en primer plano o bajo tu supervisor):
hermes gateway run

# O reinicia mediante el gestor de procesos que uses para supervisar Hermes —
# la única exigencia es que la nueva configuración o entorno surta efecto.

Paso 6: Verifica la configuración

Hermes incluye un comando de diagnóstico integrado que verifica cada parte de la integración en un solo paso:

hermes doctor

Estás buscando estas señales:

◆ Disponibilidad de herramientas
  ✓ browser-cdp        ← CDP está activo
  ✓ browser
  ...

◆ Conectividad de API
  Comprobando la API de OpenRouter...  ✓ API de OpenRouter

Si browser-cdp aparece bajo Disponibilidad de herramientas, Hermes detectó tu punto final CDP y la integración está configurada correctamente. Si falta, Hermes desactiva silenciosamente la herramienta (sin error) — ese es el diagnóstico que debes vigilar.

También puedes confirmar que Chrome es alcanzable directamente:

curl -s http://127.0.0.1:9222/json/version

Una respuesta como la siguiente confirma que CDP está activo:

{
   "Browser": "Chrome/<su versión>",
   "Protocol-Version": "1.3",
   "webSocketDebuggerUrl": "ws://127.0.0.1:9222/devtools/browser/..."
}

Sobre la visibilidad del servicio de CapSolver: Los trabajadores de servicio de Chrome MV3 se inactivan de forma agresiva, y en las últimas versiones de Chrome, /json/list puede omitirlos por completo incluso mientras están en ejecución. La ausencia en /json/list no es diagnóstica: confirma que CapSolver funciona cargando una página real de reCAPTCHA a través del agente y observando el resultado del widget en la página, no mediante la consulta de la lista de objetivos.

Cómo usarlo

Esta es la sección más importante. Una vez que la configuración esté completa, usar CapSolver con Hermes es muy sencillo.

La Regla Dorada

No menciones CAPTCHAs o CapSolver al agente. Solo déjale tiempo antes de enviar los formularios.

El agente no necesita saber sobre CAPTCHAs. La extensión maneja todo en segundo plano. Solo necesitas incluir un tiempo de espera en tus instrucciones para que la extensión tenga tiempo de resolver el desafío antes de que se envíe el formulario.

Ejemplo 1: Prueba de un solo uso

El modo de un solo uso de Hermes (hermes -z "...") es ideal para probar la integración. Ejecútalo desde cualquier terminal donde esté disponible la CLI de hermes:

hermes -z 'Abre https://www.google.com/recaptcha/api2/demo. Espera 60 segundos para que la página se cargue completamente. Luego haz clic en el botón etiquetado como "Enviar!" o con id "recaptcha-demo-submit". Después de hacer clic, espera 5 segundos y dime el texto visible en la página.' --yolo

Lo que sucede en segundo plano:

1. Hermes se conecta a tu Chrome a través de CDP
2. El agente navega a la página de demostración de reCAPTCHA de Google
3. El script de contenido de CapSolver (ejecutándose dentro de Chrome) detecta el widget de reCAPTCHA
4. El trabajador de servicio de la extensión llama a la API de CapSolver y resuelve el desafío (normalmente en 5-15 segundos)
5. El token se inyecta en el campo de formulario oculto g-recaptcha-response
6. Después de 60 segundos, el agente hace clic en Enviar
7. El servidor de Google valida el token y devuelve una página de resultado
8. El agente lee el texto posterior al envío: "Verificación exitosa... ¡Hurra!"

Esa cadena "Verificación exitosa... ¡Hurra!" es un mensaje de confirmación de Google — solo aparece cuando se envía un token válido de reCAPTCHA.

Ejemplo 2: Desde un canal de mensajería

Envía esto desde cualquier canal conectado al gateway de Hermes (Telegram, Discord, Slack, etc.):

Ve a https://example.com/iniciar-sesión, completa el campo de correo electrónico con
"me@example.com" y el campo de contraseña con "mypassword123",
luego espera 30 segundos y haz clic en el botón Iniciar sesión.
Dime qué página carga después de iniciar sesión.

Hermes enviará la solicitud al agente, se conectará al mismo Chrome, completará el formulario, dará tiempo a la extensión para resolver cualquier CAPTCHA en la página de inicio de sesión, hará clic en Iniciar sesión y responderá con lo que dice la página posterior al inicio de sesión — todo sin que tú menciones nunca CAPTCHAs.

Ejemplo 3: Enviar un formulario de contacto con reCAPTCHA

Abre https://example.com/contacto y completa el formulario de contacto:
- Nombre: "John Doe"
- Correo electrónico: "john@example.com"
- Mensaje: "Hola, tengo una pregunta sobre sus servicios."
Espera 45 segundos, luego haz clic en Enviar mensaje.
¿Qué confirmación aparece en la página?

Tiempos de espera recomendados

Consejo: Cuando estés en duda, usa 60 segundos. Es mejor esperar un poco más que enviar demasiado pronto. El tiempo adicional es esencialmente gratis — tu factura de CapSolver es por resolución, no por segundo.

Patrones de lenguaje natural que funcionan

Estas frases probadas puedes usarlas en cualquier canal de Hermes:

• "Ve a [URL], espera 60 segundos, luego envía el formulario"
• "Navega a [URL], completa los [campos], espera 30 segundos, luego haz clic en [botón]"
• "Abre [URL] y después de aproximadamente un minuto, haz clic en Enviar y dime el resultado"
• "Visita [URL], espera un momento para que la página se cargue completamente, luego envía"

Qué NO decir

Evita estas frases — pueden confundir al agente y han sido observadas para provocar rechazos en algunos modelos con seguridad ajustada (notablemente la familia GLM):

• "Espera a que se resuelva la CAPTCHA" (el agente no sabe sobre CAPTCHAs)
• "Usa CapSolver para resolver la verificación" (el agente no controla las extensiones)
• "Haz clic en la casilla de reCAPTCHA" (la extensión lo maneja — hacer clic puede interferir)
• "Evita la verificación de seguridad" (suena adversarial — algunos modelos lo rechazarán)

Cómo funciona en el interior

Para los curiosos técnicos, aquí está la arquitectura:

  Tu mensaje                  Gateway de Hermes
  ──────────────────────────────────────────────────────────
  "ve a la página,           ──►   El agente de Hermes recibe el mensaje
   espera 60s, envía"           │
                                ▼
                           herramientas de navegador / CDP
                                │  (conexión a través de WebSocket
                                │   a ws://127.0.0.1:9222)
                                ▼
                           ┌────────────────────────────────────┐
                           │  chrome-debug Chromium (fondo)     │
                           │                                     │
                           │  ┌───────────────────────────────┐ │
                           │  │ Extensión CapSolver MV3       │ │
                           │  │ (cargada mediante --load-extension; │
                           │  │  requiere Chrome para pruebas │ │
                           │  │  o Chromium — Chrome 137+ ignora esta bandera) │ │
                           │  │                                │ │
                           │  │ 1. script de contenido detecta CAPTCHA │
                           │  │ 2. trabajador de servicio llama a la API de CapSolver │
                           │  │ 3. token recibido                │ │
                           │  │ 4. token inyectado en campo de formulario │ │
                           │  └───────────────────────────────┘ │
                           └────────────────────────────────────┘
                                │
                                ▼
                           El agente de Hermes espera 60 segundos...
                                │
                                ▼
                           browser_cdp: hacer clic en Enviar
                                │
                                ▼
                           El formulario se envía CON un token válido
                                │
                                ▼
                           Página de confirmación posterior al envío

¿Por qué conectar mediante CDP en lugar de "simplemente pasar una matriz de extensiones"?

La capa de herramientas de navegador de Hermes está construida alrededor de cinco proveedores intercambiables (Browserbase, Browser Use, Firecrawl, Camoufox, Chromium sin cabeza). Tres de ellos son en la nube — no controlas el binario del navegador, por lo que no hay lugar para colocar la bandera --load-extension. Uno (Camoufox) es basado en Firefox. El quinto — conexión mediante CDP — es la única forma donde un Chromium controlado por el usuario puede ser conectado.

El intercambio es muy bueno: Hermes permanece portátil en la nube por defecto, pero en el momento en que quieras poderes superiores del lado del navegador (CapSolver, tu propio bloqueador de anuncios, herramientas MV3 personalizadas, cookies persistentes, etc.), lanzas Chrome tú mismo y apuntas a él desde Hermes. Una línea de configuración. Total control.

Qué hace realmente --load-extension

Cuando Chrome se inicia con --load-extension=/ruta/a/la/extension, lo trata como una extensión no empaquetada — el mismo mecanismo que usa el modo de desarrollador de Chrome. El manifiesto de la extensión, los scripts de contenido y el trabajador de servicio se registran exactamente como si la hubieras instalado desde la Chrome Web Store. No hay diferencia en el aislamiento, ni acceso reducido a las APIs — es una extensión plenamente privilegiada.

La extensión de CapSolver toma el control del resto:

1. Script de contenido (inyectado en cada página) vigila los widgets de CAPTCHA conocidos — reCAPTCHA, Cloudflare, AWS WAF, etc.
2. Cuando se detecta un widget, el script de contenido envía un mensaje al trabajador de servicio
3. El trabajador de servicio se autentica en la API de CapSolver usando la clave del assets/config.js, envía los detalles del desafío y consulta el token
4. Una vez que se recibe el token, se inyecta en el campo de respuesta oculto de la página mediante el script de contenido
5. Para cuando el agente hace clic en Enviar, el formulario ya lleva un token resuelto válido

El agente de Hermes no está involucrado en absoluto — ve una página normal, espera el tiempo que le dijiste y envía. La página simplemente tiene un token válido en ella.

Nota del entorno: Evita --disable-background-networking en tus flags de Chrome. Bloquea las solicitudes salientes XHR/fetch del trabajador de servicio de CapSolver — así que la extensión nunca puede llegar a la API de CapSolver. La receta en el Paso 3 omite deliberadamente esta opción.

Referencia completa de configuración

Lado de Hermes: ~/.hermes/config.yaml

El único cambio requerido es agregar cdp_url bajo el bloque browser::

browser:
  inactivity_timeout: 120
  cdp_url: http://127.0.0.1:9222

Lado de Chrome: argumentos de --load-extension

El conjunto completo de flags que debes pasar a Chrome:

Lado de CapSolver: assets/config.js

La configuración mínima en ~/.hermes/capsolver-extension/assets/config.js:

export const defaultConfig = {
  apiKey: 'CAP-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
  useCapsolver: true,
  enabledForRecaptcha: true,
  enabledForRecaptchaV3: true,
  // ... ver documentación de CapSolver para el conjunto completo de opciones
};

Solución de problemas

hermes doctor no lista browser-cdp bajo Disponibilidad de herramientas

Síntoma: Después de reiniciar Hermes, la herramienta browser-cdp no aparece en la salida de hermes doctor.

Causa: Hermes solo registra browser-cdp cuando se configura un endpoint CDP — ya sea browser.cdp_url en config.yaml, la variable de entorno BROWSER_CDP_URL, o una sesión activa de /browser connect. La verificación es presencia de configuración, no accesibilidad (ver tools/browser_cdp_tool.py:_browser_cdp_check). La causa más común de una herramienta browser-cdp faltante es un error de escritura o una clave mal anidada en config.yaml, no un Chrome inaccesible.

Solución:

# 1. Confirma que la clave está correctamente anidada bajo "browser:" (no en nivel superior)
grep -A2 '^browser:' ~/.hermes/config.yaml
# salida esperada:
#   browser:
#     ...
#     cdp_url: http://127.0.0.1:9222

# 2. Luego confirma que Chrome está realmente activo en ese endpoint
curl -s http://127.0.0.1:9222/json/version

# 3. Si Chrome está apagado, revisa el registro de chrome-debug:
tail -n 30 /tmp/chrome-debug.log     # o: journalctl --user -u chrome-debug -n 30

La extensión no carga (problema con Chrome)

Síntoma: Chrome se inicia limpiamente pero las CAPTCHAs nunca se resuelven — todos los envíos fallan.

Causa: Estás usando Chrome de Google 137+, que ignora silenciosamente --load-extension.

Solución: Cambia a Chrome para Pruebas o Chromium. Verifica tu binario:

/ruta/a/tu/chrome --version
# Chrome para Pruebas: "Chromium 143.0.7499.4"
# Chrome de Google:    "Google Chrome 143.0.7499.109"  ← no funciona

CAPTCHA no resuelto (formulario falla)

Posibles causas:

1. Tiempo de espera insuficiente — Aumenta a 60 segundos
2. Clave de API de CapSolver inválida — Verifica tu dashboard de CapSolver
3. Saldo insuficiente — Recarga tu cuenta de CapSolver
4. Red de segundo plano desactivada — Asegúrate de que no haya bandera --disable-background-networking en tus argumentos de Chrome (bloquea las llamadas salientes de la extensión)
5. Chrome de Google — ver arriba

Tiempo de espera del navegador en la primera acción tras reiniciar

Síntoma: La primera acción del navegador tras reiniciar Hermes se timeout, pero las acciones siguientes funcionan bien.

Causa: El handshake inicial de CDP puede exceder el tiempo de espera predeterminado de Hermes. Las acciones siguientes reutilizan el WebSocket caliente y son rápidas.

Solución: Vuelve a intentar el comando una vez. Si persiste, aumenta browser.inactivity_timeout en config.yaml.

Chrome se cae tras cambiar de binario

Síntoma: Después de cambiar de una versión de Chrome a otra, Chrome se cae con errores de caché en disco.

Causa: El directorio de datos de usuario fue creado por una versión diferente de Chrome e ahora es incompatible.

Solución:

# 1. Detén el proceso actual de chrome-debug (como lo supervises)
pkill -f "remote-debugging-port=9222"

# 2. Limpia el perfil antiguo
rm -rf ~/.hermes/chrome-debug

# 3. Reinicia chrome-debug (a través de tu gestor de procesos, o reinicia el script)
nohup ~/.hermes/chrome-debug.sh > /tmp/chrome-debug.log 2>&1 &

El trabajador de servicio de CapSolver no aparece en /json/list

Síntoma: curl http://127.0.0.1:9222/json/list devuelve solo entradas de page, sin service_worker.

Causa: Los trabajadores de servicio de Chrome MV3 se inactivan de forma agresiva, y en las últimas versiones de Chrome, el endpoint /json/list puede no mostrarlos en absoluto — incluso mientras están activamente manejando eventos.

Solución: Esto no es diagnóstico. No confíes en /json/list para confirmar que CapSolver está cargado. En su lugar, navega al agente a una página real protegida por reCAPTCHA (por ejemplo, https://www.google.com/recaptcha/api2/demo) y observa si el envío del formulario tiene éxito. Un envío exitoso es la prueba de que la extensión está cargada y resolviendo desafíos; una entrada faltante en la lista de objetivos no es una señal de fallo.

Mejores prácticas

1. Siempre usa tiempos de espera generosos

Más tiempo de espera siempre es más seguro. La CAPTCHA suele resolverse en 5-20 segundos, pero la latencia de red, desafíos complejos o reintentos pueden añadir tiempo. 30-60 segundos es el punto óptimo.

2. Mantén tus mensajes naturales

En lugar de:

"Navega a URL, espera a que se resuelva la CAPTCHA, luego envía"

Usa:

"Ve a la URL, espera aproximadamente un minuto, luego envía el formulario"
Una formulación natural funciona mejor con el agente y tiende a ser más amigable con modelos ajustados a la seguridad: se ha observado que el uso de lenguaje adversarial alrededor de CAPTCHAs puede provocar rechazos en algunos modelos de la clase GLM.

3. Monitorea tu saldo de CapSolver

Cada resolución de CAPTCHA consume créditos. Verifica tu saldo en capsolver.com/dashboard regularmente para evitar interrupciones.

4. Usa un directorio de datos de usuario dedicado

Nunca apuntes --user-data-dir a tu perfil de Chrome real. Usa ~/.hermes/chrome-debug (que también es el destino predeterminado del comando /browser connect integrado en Hermes). Así el navegador del agente estará completamente aislado de tu navegación personal.

5. Vincula CDP solo al bucle de bucle (loopback)

--remote-debugging-address=127.0.0.1 no es opcional en producción. El Protocolo de Herramientas de Desarrollo de Chrome otorga control total del navegador a cualquiera que pueda acceder al puerto. Nunca expongas el puerto 9222 a una red pública.

6. Usa Xvfb en servidores sin interfaz gráfica

Los complementos de Chrome requieren un contexto de visualización, incluso cuando no quieres ver el navegador. En un servidor Linux sin una pantalla física, ejecuta una virtual:

# Instalar Xvfb (Ubuntu/Debian)
sudo apt-get install xvfb

# Iniciar una pantalla virtual
Xvfb :99 -screen 0 1920x1080x24 &

# Indicar a Chrome que lo use (el lanzador chrome-debug.sh ya establece DISPLAY=:99)
export DISPLAY=:99

Si usas el lanzador chrome-debug.sh del Paso 3, la línea export DISPLAY=:99 ya está configurada — asegúrate de que Xvfb :99 esté en ejecución en el host.

7. Supervisa Chrome con un gestor de procesos en producción

Un chrome & sin control morirá cuando el shell padre termine, cuando Chrome falle o cuando el sistema se reinicie. Envuelve el lanzamiento en chrome-debug.sh (Paso 3) y supervísalo con la herramienta que ya usas para el resto de tu pila: systemd, supervisord, runit, Docker, etc. La integración es independiente del gestor de procesos; elige el que ya esté en uso en el host.

8. Combínalo con un modelo económico

Como el modelo nunca ve el CAPTCHA — el complemento lo resuelve de forma invisible — no necesitas un modelo de vanguardia para trabajos con muchos CAPTCHAs. Un modelo económico y capaz es suficiente (por ejemplo, establece provider: openrouter y default: z-ai/glm-4.6 en config.yaml). Todas las inteligencias están en el complemento; el modelo solo tiene que navegar, escribir y hacer clic.

Conclusión

La integración de Hermes + CapSolver representa un enfoque fundamentalmente nuevo para resolver CAPTCHAs en flujos de trabajo de agentes. En lugar de escribir código para detectar CAPTCHAs, llamar a APIs y inyectar tokens, simplemente:

1. Inicia Chrome una vez con --load-extension=/ruta/absoluta/a/capsolver-extension y --remote-debugging-port=9222
2. Agrega cdp_url al bloque browser: en ~/.hermes/config.yaml:
   yaml Copy

   browser:
     cdp_url: http://127.0.0.1:9222

   (nota la clave anidada — cdp_url de primer nivel se ignora silenciosamente)
3. Habla al agente de forma natural — incluye un tiempo de espera antes de enviar formularios
4. Lee el resultado normal de la página después del envío tras enviar el formulario

El complemento de Chrome de CapSolver se encarga del resto — detecta CAPTCHAs, los resuelve mediante la API de CapSolver e inyecta tokens en la página. El agente nunca necesita saber nada sobre CAPTCHAs en absoluto.

Este es el aspecto de la resolución de CAPTCHAs cuando tienes un agente de IA autónomo: invisible, automática y sin código.

¿Listo para comenzar? Regístrate en CapSolver y usa el código de bonificación herme para obtener un bono en tu primer recarga!

Preguntas frecuentes

¿Necesito informar al agente sobre CapSolver?

No. De hecho, debes evitar mencionar CAPTCHAs o CapSolver en tus mensajes. El complemento funciona de forma invisible en segundo plano. Solo incluye un tiempo de espera en tus instrucciones (por ejemplo, "espera 60 segundos, luego envía") para darle tiempo al complemento de resolver cualquier CAPTCHA en la página.

¿Por qué no puedo usar Google Chrome normal?

Google Chrome 137+ (lanzado a mediados de 2025) eliminó el soporte para la bandera de línea de comandos --load-extension en las versiones etiquetadas. Esto significa que los complementos de Chrome no se pueden cargar en sesiones automatizadas. Necesitas Chrome para pruebas o Chromium independiente, que aún soportan esta bandera.

¿Puedo usar los proveedores de navegadores en la nube de Hermes (Browserbase, Browser Use) en su lugar?

No — los proveedores en la nube ejecutan el navegador en la infraestructura de otra persona, por lo que no puedes cargar complementos arbitrarios en la sesión. El patrón de adjunta CDP en esta guía es la única forma de combinar Hermes con un complemento de Chrome. (Una vez que browser.cdp_url esté configurado en config.yaml, Hermes enruta el tráfico del navegador a través del Chrome local y los proveedores en la nube se silencian hasta que elimines la línea.)

¿Puedo usar otros navegadores además de Chrome para pruebas?

Sí — cualquier navegador basado en Chromium que aún soporte --load-extension funciona. Puedes usar:

• Chrome para pruebas (recomendado — lo que usa esta guía)
• Chromium (versión independiente)
• Chromium empaquetado por Playwright (ya está en tu sistema si alguna vez ejecutaste npx playwright install)
• Brave, Vivaldi, Opera — todos basados en Chromium, todos aceptan la bandera
• Google Chrome antiguo ≤ 136 — pero la bandera desaparece en 137+, así que no lo fijes en una versión obsoleta

La receta de integración es la misma: apunta --remote-debugging-port=9222 --load-extension=/ruta/a/capsolver-extension al binario que prefieras.

Lo que no funciona:

• Google Chrome etiquetado 137+ — ignora silenciosamente --load-extension
• Microsoft Edge — se aplicó la misma eliminación
• Navegadores basados en Firefox (Firefox, LibreWolf, Camoufox) — el complemento de CapSolver está en formato MV3 de Chrome, no en extensiones Web de Firefox
• Proveedores en la nube de Hermes (Browserbase, Browser Use, Firecrawl) — no controlas el binario remoto, así que no hay forma de cargar una extensión personalizada

¿Qué hay de Camoufox? Hermes lo respalda.

Sí — Camoufox es uno de los cinco proveedores de navegadores integrados de Hermes, y es una excelente opción de stealth basada en Firefox para tareas que no involucran un complemento de Chrome. La trampa es que Camoufox es basado en Firefox, y el complemento de CapSolver está construido en formato MV3 de Chrome — así que no pueden funcionar juntos en una misma sesión.

Buena noticia: con Hermes no necesitas elegir permanentemente. La configuración browser.cdp_url en ~/.hermes/config.yaml es un interruptor único — apúntalo a tu Chrome con CapSolver cuando necesites resolver CAPTCHAs, y apúntalo a Camoufox cuando necesites stealth de Firefox. Un conjunto típico mantiene ambos en ejecución:

# Línea activa: cambia entre perfiles comentando o descomentando
browser:
  cdp_url: http://127.0.0.1:9222          # Chrome con CapSolver (esta guía)
  # cdp_url: http://127.0.0.1:9333        # Punto de conexión de Camoufox

Luego reinicia Hermes (hermes gateway run, o activa un reinicio a través de lo que supervise el gateway en tu sistema) y el cambio toma efecto en segundos. El mismo Hermes, los mismos canales, las mismas habilidades — un navegador diferente por trabajo.

¿Funciona el comando /browser connect de Hermes con esta configuración?

Sí. El comando slash /browser connect integrado en Hermes (en la interfaz de línea de comandos interactiva hermes) apunta al mismo directorio de datos de usuario predeterminado que usamos (~/.hermes/chrome-debug) y al mismo puerto (9222). Una vez que hayas configurado el sidecar de chrome-debug, puedes usar /browser connect desde dentro de Hermes de forma interactiva, o dejar browser.cdp_url en config.yaml para una conexión permanente — ambos funcionan contra el mismo Chrome.

¿Qué pasa al usar Hermes a través de canales de mensajería?

La integración es completamente independiente del canal. Una vez que browser.cdp_url esté configurado en config.yaml, toda acción del navegador — ya sea desde hermes -z en la CLI, la interfaz de línea de comandos interactiva hermes, o un mensaje de Telegram, Discord, Slack, WhatsApp, Signal o correo electrónico — se enruta a través de tu Chrome con CapSolver. El complemento resuelve los CAPTCHAs de forma idéntica en todos los casos.

¿Debo usar la página de demostración de Google en pruebas automatizadas?

Úsala solo como prueba rápida. En la FAQ oficial de reCAPTCHA de Google, recomiendan crear claves de sitio dedicadas para pruebas automatizadas en lugar de depender de la página de demostración pública en pipelines de producción.

¿Qué tipos de CAPTCHA soporta el complemento de CapSolver?

El complemento de Chrome de CapSolver resuelve automáticamente reCAPTCHA v2 (casilla y invisible), reCAPTCHA v3, Cloudflare, AWS WAF CAPTCHA y otros widgets ampliamente utilizados. El script de contenido detecta el tipo de CAPTCHA en la página y lo resuelve en consecuencia — no se requiere configuración por tipo en tu lado. (Nota: Cloudflare Turnstile y Cloudflare 5-second Challenge no se resuelven con el complemento de navegador; solo están disponibles a través de la API de CapSolver y están fuera del alcance de esta guía.)

¿Cuánto cuesta CapSolver?

CapSolver ofrece precios competitivos basados en el tipo de CAPTCHA y el volumen. Visita capsolver.com para ver los precios actuales.

¿Es gratuito Hermes Agent?

Hermes Agent es de código abierto (github.com/NousResearch/hermes-agent) y gratuito para ejecutar en tu propio hardware. Necesitarás claves de API para el proveedor de modelos de IA de tu elección (se recomienda OpenRouter — Hermes admite más de 200 modelos a través de él) y, para resolver CAPTCHAs, una cuenta de CapSolver con créditos.

¿Cuánto tiempo debo decirle al agente que espere?

Para la mayoría de los CAPTCHAs, 30-60 segundos es suficiente. El tiempo de resolución real suele ser de 5-20 segundos, pero agregar un tiempo adicional asegura la confiabilidad. Si dudas, usa 60 segundos.

¿Puedo usar esto en un servidor sin interfaz gráfica?

Sí. Necesitarás Xvfb (X Virtual Framebuffer) para la visualización ya que los complementos de Chrome requieren un contexto de visualización. Ejecuta Xvfb :99 -screen 0 1920x1080x24 & en el host y asegúrate de que DISPLAY=:99 esté exportado en el lanzador chrome-debug.sh (el lanzador del Paso 3 ya lo hace). También mantén --no-sandbox en los argumentos de Chrome ya que la mayoría de los kernels de servidor no otorgan las capacidades que requiere el sandbox de Chrome.

¿Puedo ejecutar múltiples instancias de Hermes apuntando al mismo chrome-debug?

Técnicamente sí, pero tendrás que gestionar tú mismo la contención de pestañas/sesiones. Para la mayoría de los trabajos, una sola instancia de Hermes ↔ una sola instancia de chrome-debug es la configuración más limpia. Si necesitas paralelismo real, ejecuta múltiples sidecars de chrome-debug en puertos diferentes (9222, 9223, ...) y apunta cada Hermes a su propio.

¿Funciona esto con Habilidades de Hermes?

Sí. Las Habilidades de Hermes son memorias procedurales — secuencias de pasos que el agente ha aprendido. Una habilidad que involucra sitios web con CAPTCHAs beneficiará automáticamente de la integración de CapSolver de la misma forma que un mensaje ad-hoc, porque es la herramienta del navegador la que se está mejorando. No se necesitan cambios en la habilidad.