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

Cuando tu agente de IA navega por la web por ti, CAPTCHAs son el principal obstáculo. 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 que se mejora a sí mismo y 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 queda atascado en los CAPTCHAs.

CapSolver lo cambia 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 de todo es que ni siquiera necesitas mencionar 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 de habilidades autónoma (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 múltiples canales: 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 + Chrome DevTools Protocol

La herramienta del navegador

Hermes puede controlar un navegador Chromium para realizar trabajo real: navegar, leer DOM, hacer clic, escribir, capturar pantallazos, 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 Chrome MV3. El punto de integración limpio es el quinto: CDP attach, donde Hermes se conecta a un Chromium tú lanzaste por separado. Ese es el lugar donde entra CapSolver.

Este es un modelo diferente a 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 CAPTCHA que proporciona soluciones impulsadas por IA para evitar desafíos modernos de CAPTCHA. Con soporte para cada tipo de CAPTCHA importante 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 del 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 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 de 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 e 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 que "resuelva 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 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 etiquetadas. 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 uno de estos alternativos:

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 trabajando juntas:

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 config.yaml de Hermes para indicarle 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 Chrome de CapSolver y cópiala 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 versiones 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: 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 la configuración
};

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

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

Este es el paso clave. Lanzamos Chrome una vez, separadamente de Hermes, con tres banderas 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 automáticamente" sin banderas adicionales.

Opción A: Lanzamiento manual de un solo uso (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 Mejores prácticas a continuación para la configuración de Xvfb. El subsistema de extensiones 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 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:

#!/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 sin cabeza — ver 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 sencillo 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 unidad systemd mínima en ~/.config/systemd/user/chrome-debug.service:

[Unit]
Descripción=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 forma idéntica — la integración solo se preocupa de que algo mantenga chrome-debug.sh en ejecución.

Paso 4: Decirle 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

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

Reversibilidad: Esta es la única modificación a Hermes. Para revertir, elimina la línea cdp_url. Hermes regresa a cualquier proveedor de navegador predeterminado que estuviera usando (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 cualquier gestor de procesos que supervises a Hermes —
# la única exigencia es que la nueva env/config tome 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 golpe:

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 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/..."
}

Acerca de la visibilidad del servicio de trabajo 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. Todo lo que necesitas hacer es 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 humo 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 el id "recaptcha-demo-submit". Después de hacer clic, espera 5 segundos y dime el texto visible en la página.' --yolo

Lo que ocurre 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 (que se ejecuta 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 de "Verificación exitosa... ¡Hurra!" 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/login, 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 redirigirá la solicitud a su 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 diga 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 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 se cobra por resolución, no por segundo.

Patrones de lenguaje natural que funcionan

Estas son frases probadas que puedes usar en cualquier canal de Hermes:

• "Ve a [URL], espera 60 segundos, luego envía el formulario"
• "Navega a [URL], completa [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] y espera un momento para 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 ajustes de seguridad (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 se negarán)

Cómo funciona bajo el capó

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 / browser_cdp
                                │  (se conecta 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                │ │
                           │  └───────────────────────────────┘ │
                           └────────────────────────────────────┘
                                │
                                ▼
                           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 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 la bandera --load-extension. Uno (Camoufox) es basado en Firefox. El quinto — conexión CDP — es la única forma donde un Chromium controlado por el usuario puede ser conectado.

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

Qué hace realmente --load-extension

Cuando Chrome se inicia con --load-extension=/ruta/a/la/extensión, trata ese directorio 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 hubieras instalado la extensión 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, 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 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

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 de 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 alcanzar 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 --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 documentos de CapSolver para el conjunto completo de opciones
};

Solución de problemas

hermes doctor no muestra browser-cdp bajo Disponibilidad de herramientas

Síntoma: Después de reiniciar Hermes, la herramienta browser-cdp está ausente 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 ausente 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á caído, revisa el log 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 --version
# Chrome para Pruebas: "Chromium 143.0.7499.4"
# Chrome de marca:    "Google Chrome 143.0.7499.109"  ← no funciona

CAPTCHA no resuelto (el formulario falla)

Posibles causas:

1. Tiempo de espera insuficiente — Aumenta a 60 segundos
2. Clave de API de CapSolver inválida — Verifica tu panel de CapSolver
3. Saldo insuficiente — Recarga tu cuenta de CapSolver
4. Red de fondo 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 marca — ver arriba

Tiempo de espera del navegador en la primera acción después de reiniciar

Síntoma: La primera acción del navegador después de reiniciar Hermes se bloquea, pero las acciones posteriores funcionan bien.

Causa: El handshake CDP de inicio puede exceder ocasionalmente el tiempo de espera predeterminado de Hermes. Las 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 después de cambiar de binarios

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

Causa: El user-data-dir 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. Elimina el perfil obsoleto
rm -rf ~/.hermes/chrome-debug

# 3. Reinicia chrome-debug (a través de tu gestor de procesos, o vuelve a ejecutar 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 de lista de objetivos ausente 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 generalmente se resuelve 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 URL, espera aproximadamente un minuto, luego envía el formulario"
La frase natural funciona mejor con el agente y tiende a ser más amigable con los modelos ajustados a la seguridad — se ha observado que el uso de lenguaje adversarial alrededor de los CAPTCHAs puede provocar rechazos en algunos modelos de clase GLM.

3. Supervisa 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 objetivo 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 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 quieras 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 &

# Indica 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 en la parte superior ya maneja esto — 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 salga su shell padre, cuando Chrome se cuelgue o cuando se reinicie la máquina. Envuelve el lanzamiento en chrome-debug.sh (Paso 3) y supervísalo con lo 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 ejecución en la máquina.

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.

9. Confía en el historial

La infraestructura de CapSolver que impulsa esta integración de Hermes ya maneja reCAPTCHA v2/v3, Cloudflare Turnstile y desafíos de AWS WAF en pipelines de automatización en producción — esto no es un trabajo de un solo uso cosido para este tutorial, es la misma capa de resolución que equipos ya usan para scraping a gran escala y automatización de pruebas.

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 e inyectar tokens, simplemente:

1. Lanza Chrome una vez con --load-extension=/abs/path/to/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 — simplemente incluye un tiempo de espera antes de enviar formularios
4. Lee el resultado normal de la página después del envío después de enviar el formulario

El complemento de Chrome de CapSolver maneja el resto — detecta CAPTCHAs, los resuelve mediante la API de CapSolver e inyecta tokens en la página. Al agente nunca le importa los CAPTCHAs en absoluto.

Este es el aspecto de la resolución de CAPTCHAs cuando tienes un agente de IA autónomo: invisible, automático 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, deberías evitar mencionar CAPTCHAs o CapSolver en tus mensajes. El complemento funciona de forma invisible en segundo plano. Simplemente 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 regular?

Google Chrome 137+ (lanzado a mediados de 2025) eliminó el soporte para la bandera de línea de comandos --load-extension en las versiones de marca. 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 este 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 de 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 este guía usa)
• Chromium (versión independiente)
• Chromium empaquetado por Playwright (ya está en tu máquina si alguna vez ejecutaste npx playwright install)
• Brave, Vivaldi, Opera — todos basados en Chromium, todos aceptan la bandera
• Versiones antiguas de Google Chrome ≤ 136 — pero la bandera se elimina 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=/path/to/capsolver-extension al binario que prefieras.

Lo que no funciona:

• Google Chrome de marca 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 Chrome MV3, no en WebExtensions de Firefox
• Los proveedores de navegadores 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é pasa con 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 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 interruptor único — apúntalo a tu Chrome con CapSolver cuando necesites resolver CAPTCHAs, y apúntalo a Camoufox cuando necesites stealth de Firefox. Una configuración típica 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 (este 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 supervisa el gateway en tu máquina) y el cambio toma efecto en segundos. El mismo Hermes, los mismos canales, las mismas habilidades — un navegador diferente por carga de 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 usuario 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 chrome-debug, puedes usar /browser connect desde dentro de Hermes interactivamente, o dejar browser.cdp_url en config.yaml para una conexión permanente — ambos funcionan contra el mismo Chrome.

¿Qué pasa con 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 usuario interactiva hermes, o un mensaje desde 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 e invisible), reCAPTCHA v3, Cloudflare, CAPTCHA de AWS WAF 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 el desafío de 5 segundos de Cloudflare 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 este 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 el agente Hermes?

Hermes Agent es de código abierto (github.com/NousResearch/hermes-agent) y es 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 soporta 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 real de resolución 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 el contenido de pestañas/sesiones tú mismo. Para la mayoría de las cargas de trabajo, 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 procedurales — secuencias de pasos que el agente ha aprendido. Un Skill que involucra navegar en sitios con CAPTCHA protegidos beneficiará automáticamente de la integración de CapSolver de la misma forma que lo haría un mensaje ad-hoc, porque es la herramienta del navegador la que se está mejorando. No se necesitan cambios en el Skill.