Cómo resolver CAPTCHA en automatización de navegadores con Hermes Agent y CapSolver

Cuando tu agente de IA navega por la web por ti, los CAPTCHAs son el principal obstáculo. Páginas protegidas bloquean al agente, 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 alcanza a través de cada canal que ya usas: Telegram, Discord, Slack, WhatsApp, Signal y correo electrónico. También puede manejar un navegador para navegar páginas, hacer clic en botones, completar formularios y extraer datos en tu nombre. Pero como cualquier agente que maneja un navegador, se atasca con los CAPTCHAs.

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

Lo mejor es que ni siquiera necesitas mencionar los CAPTCHAs 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 creado 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 repite la próxima vez) y flexibilidad de infraestructura (puedes ejecutarlo en un VPS pequeño, un contenedor Docker, un entorno sin servidor o en tu propia 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 de 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: Conduce un Chromium real mediante Playwright + Protocolo de herramientas de desarrollo de Chrome

La herramienta del navegador

Hermes puede manejar un navegador Chromium para realizar trabajo real: navegar, leer DOM, hacer clic, escribir, tomar capturas de pantalla, extraer datos. Su capa de herramienta de navegador es inusual en un aspecto específico: en lugar de obligarte a un único backend, Hermes admite cinco proveedores de navegador intercambiables:

Los proveedores en la nube no pueden cargar extensiones — no controlas el navegador remoto. Camoufox se basa 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ú lanzado separadamente. Ese es el lugar donde CapSolver encaja.

Este es un modelo diferente al de herramientas como OpenClaw (que lanza su propio Chromium y acepta una matriz 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 de resolución de CAPTCHAs que proporciona soluciones impulsadas por IA para superar los desafíos modernos de CAPTCHA. Con soporte para cada tipo principal de CAPTCHA y tiempos de respuesta rápidos, CapSolver se integra sin problemas en flujos de trabajo automatizados — ya sea que estés manejando un navegador mediante Playwright, llamando directamente a su API o, como en esta guía, ejecutando su extensión de Chrome dentro de una sesión de navegador del agente.

¿Por qué esta integración es diferente?

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

Hermes + CapSolver es fundamentalmente diferente:

La clave del insight: La extensión de CapSolver se ejecuta dentro del navegador conectado. Hermes se conecta a ese navegador a través del CDP y lo maneja 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 hace 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 dices:

"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 la 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 con marca. Esto significa que las extensiones de Chrome no se pueden cargar en sesiones automatizadas usando Google Chrome estándar. No hay error — la bandera 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 coincida con 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 piezas que trabajan juntas:

1. Un proceso de Chrome separado que lanzas con la extensión de CapSolver precargada y el CDP expuesto en un puerto conocido (usaremos 9222).
2. Un pequeño cambio en config.yaml de Hermes para que le diga 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: Descargar la extensión de Chrome de CapSolver

Descarga la extensión de CapSolver de Chrome 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 especiales donde los trabajadores de servicio de extensión fallan en registrarse 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: Establecer 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 configuración
};

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

Paso 3: Iniciar Chrome con la extensión y el CDP habilitado

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

• --remote-debugging-port=9222 — expone el protocolo de herramientas de desarrollo 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 solo" sin banderas adicionales.

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

/ruta/a/chrome-para-pruebas/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 /ruta/a/chrome-para-pruebas/chrome con tu binario real, por ejemplo ~/.cache/ms-playwright/chromium-1200/chrome-linux64/chrome.

Servidores en modo sin cabeza: Si estás ejecutando esto en un servidor Linux sin una pantalla física (un VPS, EC2, etc.), consulta la sección de Prácticas recomendadas a continuación para la configuración de Xvfb. El subsistema de extensión de Chrome requiere un contexto de pantalla.

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 ejecutándose 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
# Inicia Chrome para pruebas con la extensión de CapSolver precargada
# y el 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 sin cabeza — ver Prácticas recomendadas

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

La forma más sencilla de lanzar en modo persistente 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. Un archivo de unidad systemd mínimo 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 igualmente — la integración solo se preocupa de que algo mantenga chrome-debug.sh en ejecución.

Paso 4: Decirle a Hermes que se conecte por 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

Esta única línea le dice a la herramienta browser_cdp de Hermes que dirija todas las operaciones del navegador a través del ejemplo de Chrome que lanzamos en el Paso 3, en lugar de iniciar su propio.

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

Paso 5: Reiniciar Hermes

Si Hermes ya está en ejecución, reinícalo para que tome la nueva 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 a Hermes —
# lo único que se requiere es que la nueva env/config surta efecto.

Paso 6: Verificar la configuración

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

hermes doctor

Buscas estas señales:

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

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

Si browser-cdp aparece bajo Disponibilidad de herramientas, Hermes ha detectado tu punto de conexión CDP y la integración está correctamente configurada. Si falta, Hermes deshabilita silenciosamente la herramienta (sin error) — esa es la señal a 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 el CDP está activo:

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

Acerca del visibilidad del trabajador de servicio de CapSolver: Los trabajadores de servicio de Chrome MV3 se quedan inactivos con mucha facilidad, y en construcciones recientes de Chrome, /json/list podría 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 encuesta 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 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 disparo

El modo de un solo disparo 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 "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 (en ejecución 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... ¡Aleluya!"

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

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 menciones jamás 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 tengas dudas, 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 a que la página se cargue completamente, luego envía"

Lo que NO decir

Evita estas frases — pueden confundir al agente y han sido observadas para provocar rechazos en algunos modelos con seguridad ajustada (especialmente 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 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 con --load-extension; │ │
                           │  │  requiere Chrome para pruebas │ │
                           │  │  o Chromium — Chrome 137+ ignora este flag) │ │
                           │  │                                │ │
                           │  │ 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 token válido
                                │
                                ▼
                           Página de confirmación tras el envío

¿Por qué conectar mediante CDP en lugar de "Simplemente pasar una lista de extensiones"?

La capa de herramientas de navegador de Hermes está construida alrededor de cinco proveedores intercambiables (Browserbase, Browser Use, Firecrawl, Camoufox, Chromium headless). Tres de ellos son en la nube — no controlas el binario del navegador, así 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 conectarse.

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 Hermes a él. 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. La extensión se registra exactamente como si la hubieras instalado desde la Chrome Web Store. No hay diferencia en el aislamiento, ni acceso reducido a las API — 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, hCaptcha, FunCaptcha, 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 de 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 este flag.

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,
  // ... consulta la documentación de CapSolver para el conjunto completo de alternativas
};

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 punto final 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 ortografía 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 disponible en ese punto final
curl -s http://127.0.0.1:9222/json/version

# 3. Si Chrome está caído, 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 de marca)

Síntoma: Chrome se inicia limpiamente pero las CAPTCHAs nunca se resuelven — cada envío falla.

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

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

/ruta/a/tu/chrome --versión
# Chrome para pruebas: "Chromium 143.0.7499.4"
# Chrome de marca:    "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 — Revisa tu panel de CapSolver
3. Saldo insuficiente — Recarga tu cuenta de CapSolver
4. Red de fondo desactivada — Asegúrate de que no haya ninguna bandera --disable-background-networking en tus argumentos de Chrome (bloquea las llamadas salientes de la extensión)
5. Chrome de marca — 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 detiene, pero las acciones posteriores funcionan bien.

Causa: El handshake inicial CDP puede exceder el tiempo de espera predeterminado de Hermes. Acciones posteriores 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 cierra tras cambiar de binario

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

Causa: El directorio de datos de usuario fue creado por una versión diferente de Chrome y 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 quedan inactivos con mucha facilidad, y en construcciones recientes de Chrome, el punto final /json/list podría no mostrarlos en absoluto — incluso mientras están activamente manejando eventos.

Solución: Esto no es diagnóstico. No dependas de /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 al solucionador de CAPTCHA, luego envía"

Usa:

"Ve a URL, espera unos minutos, luego envía el formulario"
La formulación natural funciona mejor con el agente y tiende a ser más amigable con los modelos ajustados en seguridad — se ha observado que el lenguaje adversarial alrededor de los CAPTCHAs puede desencadenar rechazos en algunos modelos de tipo GLM.

3. Supervisa tu saldo en CapSolver

Cada resolución de CAPTCHA cuesta 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 real de Chrome. 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 local

--remote-debugging-address=127.0.0.1 es no 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 si no quieres ver el navegador. En un servidor Linux sin pantalla física, ejecuta una pantalla 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 en la parte superior — 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 se detendrá cuando el shell padre finalice, si Chrome falla o si el equipo se reinicia. Envuelve el lanzamiento en chrome-debug.sh (Paso 3) y supervísalo con el gestor que ya uses para el resto de tu pila — systemd, supervisord, runit, Docker, etc. La integración es compatible con cualquier gestor de procesos; elige el que ya esté en uso en el host.

8. Combínalo con un modelo barato

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 funcional es suficiente (por ejemplo, establece provider: openrouter y default: z-ai/glm-4.6 en config.yaml). Todo el inteligencia está en el complemento; el modelo solo debe 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 APIs y inyectar tokens, simplemente:

1. Inicia Chrome una vez con --load-extension=/ruta/absoluta/al/extension/capsolver y --remote-debugging-port=9222
2. Añade 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 posterior al envío después de enviar el formulario

El complemento Chrome de CapSolver se encarga del resto — detecta CAPTCHAs, los resuelve a través de la API de CapSolver y 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 Chrome de Google regular?

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 pueden cargarse en sesiones automatizadas. Necesitas Chrome para Pruebas o Chromium independiente, que aún soportan esta bandera.

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

No — los proveedores en la nube ejecutan el navegador en la infraestructura de terceros, por lo que no puedes cargar complementos arbitrarios en la sesión. El patrón CDP de conexión 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 redirige el tráfico del navegador a 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
• Versiones anteriores de Google Chrome ≤ 136 — pero la bandera desaparece en 137+, así que no te quedes en una versión obsoleta

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

Lo que no funciona:

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

¿Qué tal Camoufox? Hermes lo soporta.

Sí — Camoufox es uno de los cinco proveedores de navegador integrados de Hermes, y es una excelente opción de stealth basada en Firefox para tareas que no involucran un complemento de Chrome. El problema es que Camoufox es basado en Firefox, y el complemento de CapSolver está construido en formato Chrome MV3 — así que no pueden ejecutarse 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 solo interruptor — apúntalo a tu Chrome con CapSolver cuando necesites resolver CAPTCHAs, y apúntalo a Camoufox cuando necesites stealth de Firefox. Un entorno típico mantiene ambos en ejecución:

# Línea activa: cambia entre perfiles comentando/eliminando comentarios
browser:
  cdp_url: http://127.0.0.1:9222          # Chrome con CapSolver (esta guía)
  # cdp_url: http://127.0.0.1:9333        # Punto final 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 — navegador diferente por trabajo.

¿Funciona el comando /browser connect de Hermes con este ajuste?

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é tal 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, desde la interfaz de línea de comandos interactiva hermes, o desde 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 la misma forma 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 Chrome de CapSolver resuelve automáticamente reCAPTCHA v2 (casilla y invisible), reCAPTCHA v3, hCaptcha, FunCaptcha, AWS WAF CAPTCHA y otros widgets ampliamente implementados. El script de contenido detecta el tipo de CAPTCHA en la página y lo resuelve en consecuencia — no necesitas configuración por tipo en tu lado. (Nota: Cloudflare Turnstile y Cloudflare 5-second Challenge no son resueltos por 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 volumen. Visita capsolver.com para conocer los precios actuales.

¿Es gratis Hermes Agent?

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

¿Cuánto tiempo debo indicarle 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 buffer 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 la contención de pestañas/sesiones por tu cuenta. Para la mayoría de los trabajos, una única instancia de Hermes ↔ una única 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 Skills de Hermes?

Sí. Los Skills de Hermes son memorias progresivas — secuencias de pasos que el agente ha aprendido. Un Skill que involucre navegación en sitios con CAPTCHA beneficiará automáticamente de la integración de CapSolver de la misma forma que un mensaje ad-hoc, ya que es la herramienta de navegador la que se está mejorando. No se necesitan cambios en el Skill.