Cómo resolver Captcha en Nanobot con CapSolver

Cuando tu asistente de IA automatiza tareas en la web, los CAPTCHAs son el principal bloqueo. Las páginas protegidas no se envían, los flujos de inicio de sesión se detienen y todo el ciclo de automatización se detiene esperando a un humano.

Nanobot es un marco de asistente de IA ultra ligero que puedes ejecutar en tu propio hardware. Se conecta a los canales que ya usas — WhatsApp, Telegram, Discord, Slack, Correo electrónico, y más — y viene con una herramienta exec integrada que permite al agente escribir y ejecutar scripts de forma autónoma.

CapSolver proporciona una API de resolución de CAPTCHA impulsada por IA. Al combinar las capacidades de ejecución de scripts de Nanobot con la API REST de CapSolver, tu agente puede detectar CAPTCHAs, resolverlos, inyectar tokens y enviar formularios — todo sin intervención humana.

Lo mejor de todo es que simplemente le dices al agente lo que quieres que haga en lenguaje cotidiano. Escribe un script de Playwright, extrae el sitekey, llama a CapSolver, inyecta el token y envía el formulario — todo de forma autónoma.

¿Qué es Nanobot?

Nanobot es un marco de asistente de IA personal en ~3,500 líneas de código Python. Está diseñado para ser ligero, extensible y autohospedado.

Características principales

• Bandeja de entrada multi-canal: Habla con tu IA desde WhatsApp, Discord, Telegram, Slack, Correo electrónico, QQ, y más
• Herramientas integradas: El agente puede leer/escribir archivos, ejecutar comandos de shell, buscar en la web, obtener páginas, enviar mensajes entre canales y crear tareas en segundo plano
• Independiente de proveedores: Funciona con Anthropic, OpenAI, DeepSeek, Gemini, Qwen, Moonshot, Zhipu, Groq, vLLM y proveedores de pasarela como OpenRouter
• Primero en local: Se ejecuta en tu propio hardware — tus datos permanecen contigo
• Sistema de memoria: Notas diarias y memoria a largo plazo que persiste entre conversaciones
• Sistema de habilidades: Extiende con habilidades integradas o personalizadas para tareas especializadas

La herramienta Exec

La herramienta exec de Nanobot es lo que hace posible la automatización del navegador. El agente puede ejecutar cualquier comando de shell, incluidos scripts de Node.js que controlan un navegador headless. Cuando le pides al agente que interactúe con una página web, hace lo siguiente:

1. Escribe un script de Playwright
2. Lo ejecuta mediante la herramienta exec
3. Lee la salida y las capturas de pantalla
4. Informa los resultados de vuelta a través de tu canal de chat

Imagínalo como darle acceso completo por línea de comandos a tu asistente de IA — puede instalar herramientas, escribir scripts y ejecutarlos, todo desde una instrucción en lenguaje natural.

¿Qué es CapSolver?

CapSolver es un servicio líder de resolución de CAPTCHA que proporciona soluciones impulsadas por IA para evitar diversos desafíos de CAPTCHA. Con soporte para múltiples tipos de CAPTCHA y tiempos de respuesta rápidos, CapSolver se integra sin problemas en flujos de trabajo automatizados.

Tipos de CAPTCHA soportados

• reCAPTCHA v2 (basado en imágenes e invisible)
• reCAPTCHA v3 & v3 Enterprise
• Cloudflare Turnstile
• Cloudflare 5-second Challenge
• AWS WAF CAPTCHA
• Otros mecanismos de CAPTCHA y anti-bot ampliamente utilizados

¿Por qué el enfoque de Nanobot es diferente?

La mayoría de las integraciones de resolución de CAPTCHA se dividen en dos categorías: integración de API a nivel de código donde escribes una clase de servicio dedicada, o extensión de navegador donde una extensión de Chrome maneja todo de forma invisible. Nanobot toma un tercer enfoque: integración de API impulsada por el agente.

El agente en sí mismo orquesta todo el proceso de resolución de forma autónoma — escribiendo un script de Playwright, extrayendo el sitekey, llamando a la API de CapSolver y inyectando el token de solución — todo a través de scripts que escribe y ejecuta en tiempo real.

La clave del insight: El agente de Nanobot no necesita una extensión de navegador porque puede llamar programáticamente a la API de CapSolver, extraer el sitekey del DOM de la página y inyectar el token de solución — todo a través de scripts de Playwright que ejecuta mediante la herramienta exec. Esto funciona en entornos completamente headless sin necesidad de configuración de pantalla.

Requisitos previos

Nota: Los ejemplos a continuación se probaron en Ubuntu 22.04 / 24.04. Los comandos usan apt y bash — ajusta según tu distribución si es necesario.

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

1. Ubuntu 22.04+ (o cualquier Linux basado en Debian — otras distribuciones funcionan con paquetes equivalentes)
2. Python 3.11+ instalado (sudo apt install python3 python3-pip python3-venv)
3. Nanobot instalado y en ejecución (pip install nanobot-ai o pip install -e ".[dev]")
4. Una cuenta de CapSolver con clave de API (regístrate aquí)
5. Node.js 18+ instalado (para ejecutar scripts de Playwright)
6. Playwright instalado en tu espacio de trabajo

Configuración paso a paso

Paso 1: Instalar Nanobot

# Instalar desde PyPI
pip install nanobot-ai

# O instalar desde el código fuente para desarrollo
git clone https://github.com/HKUDS/nanobot.git
cd nanobot
pip install -e ".[dev]"

# Inicializar configuración y espacio de trabajo
nanobot onboard

Paso 2: Establecer la clave de API de CapSolver

Agrega tu clave de API de CapSolver como variable de entorno:

export CAPSOLVER_API_KEY="CAP-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

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

Para una configuración persistente, agrégala a tu perfil de shell (~/.bashrc o ~/.zshrc).

Paso 3: Instalar herramientas de automatización de navegadores

Instala Playwright y sus dependencias del sistema en Ubuntu:

# Instalar dependencias del navegador de Playwright (Ubuntu)
sudo apt install -y libnss3 libatk-bridge2.0-0 libdrm2 libxcomposite1 \
  libxdamage1 libxrandr2 libgbm1 libpango-1.0-0 libasound2t64

# Instalar Playwright en tu espacio de trabajo de nanobot
cd ~/.nanobot/workspace
npm init -y
npm install playwright
npx playwright install chromium

Paso 4: Iniciar el gateway

# Iniciar servicios de canales (Telegram, Discord, etc.)
nanobot gateway

# O para pruebas interactivas
nanobot agent

Paso 5: Verificar la configuración

Envía un mensaje de prueba a tu agente a través de cualquier canal conectado:

¿Qué herramientas tienes disponibles?

El agente debe listar exec entre sus herramientas — esta es la que usa para ejecutar scripts de automatización del navegador.

La habilidad integrada de CapSolver

Nanobot incluye una habilidad integrada de capsolver que está siempre cargada en el prompt del sistema del agente. Esto significa que en cada mensaje, el agente ya tiene los documentos de la API de CapSolver correctos, tipos de tareas, patrones de código y instrucciones de ejecución en su contexto — nunca tiene que adivinar o buscar.

¿Cómo funcionan las habilidades en Nanobot?

Las habilidades son archivos markdown en nanobot/skills/{name}/SKILL.md con metadatos YAML. Cuando se establece always: true en los metadatos, el contenido completo de la habilidad se inyecta automáticamente en el prompt del sistema del agente. El agente no necesita llamar a read_file — simplemente lo sabe.

El archivo de habilidad (nanobot/skills/capsolver/SKILL.md)

Para instalar la habilidad, crea el archivo nanobot/skills/capsolver/SKILL.md con este contenido:

---
name: capsolver
description: "Resolver CAPTCHAs usando la API REST de CapSolver con Playwright. Soporta reCAPTCHA v2, reCAPTCHA v3 y Cloudflare Turnstile. Úsalo al automatizar envíos de formularios o interacciones en páginas que encuentren desafíos de CAPTCHA."
metadata: {"nanobot":{"emoji":"🔓","always":true,"requires":{"bins":["node"],"env":["CAPSOLVER_API_KEY"]}}}
---

# CapSolver

## IMPORTANTE: Ejecución requerida

Cuando un usuario te pide resolver un CAPTCHA, DEBES llamar inmediatamente a una herramienta. NO respondas con texto como "Ejecutando..." o "Comenzaré..." o "He iniciado la automatización...".

Tu primera acción debe ser una de las siguientes:
1. Llama a `write_file` para guardar un script de Node.js, luego llama a `exec` para ejecutarlo
2. Llama a `spawn` con una descripción detallada de la tarea para ejecución en segundo plano

Si respondes solo con texto y sin llamada a herramienta, el usuario no verá nada. Siempre ejecuta.

## Puntos de acceso de API

- **Crear tarea**: `POST https://api.capsolver.com/createTask`
- **Obtener resultado**: `POST https://api.capsolver.com/getTaskResult`

## Tipos de tarea

| CAPTCHA | Tipo de tarea | Ubicación del sitekey |
|---|---|---|
| reCAPTCHA v2 | `ReCaptchaV2TaskProxyLess` | atributo `data-sitekey` |
| reCAPTCHA v3 | `ReCaptchaV3TaskProxyLess` | llamada `grecaptcha.execute` o fuente de la página |
| Cloudflare Turnstile | `AntiTurnstileTaskProxyLess` | `data-sitekey` en el div de Turnstile |

Variantes empresariales: `ReCaptchaV2EnterpriseTaskProxyLess`, `ReCaptchaV3EnterpriseTaskProxyLess`.

## Flujo de trabajo

1. Navega a la página con Playwright (Chromium headless)
2. Extrae el sitekey del DOM (`[data-sitekey]` attribute)
3. Llama a `createTask` con el sitekey y la URL de la página
4. Consulta `getTaskResult` cada 2 segundos hasta que `status: "ready"`
5. Inyecta el token en la página (campo de formulario oculto)
6. Envía el formulario

## Patrón de código principal

```javascript
const CAPSOLVER_API_KEY = process.env.CAPSOLVER_API_KEY;

// Paso 1: Crear tarea
const createRes = await fetch('https://api.capsolver.com/createTask', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    clientKey: CAPSOLVER_API_KEY,
    task: {
      type: 'ReCaptchaV2TaskProxyLess',  // o ReCaptchaV3TaskProxyLess, AntiTurnstileTaskProxyLess
      websiteURL: pageUrl,
      websiteKey: siteKey
    }
  })
});
const { taskId } = await createRes.json();

// Paso 2: Consultar resultado
let token;
while (true) {
  await new Promise(r => setTimeout(r, 2000));
  const res = await fetch('https://api.capsolver.com/getTaskResult', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ clientKey: CAPSOLVER_API_KEY, taskId })
  });
  const result = await res.json();
  if (result.status === 'ready') { token = result.solution.gRecaptchaResponse || result.solution.token; break; }
  if (result.status === 'failed') throw new Error('Resolución fallida');
}

// Paso 3: Inyectar token (reCAPTCHA)
await page.evaluate((t) => {
  document.querySelectorAll('textarea[name="g-recaptcha-response"]')
    .forEach(el => { el.value = t; el.innerHTML = t; });
}, token);
```

Para Turnstile, el campo del token suele ser `input[name="cf-turnstile-response"]` y la solución está en `result.solution.token`.

## Referencia completa de API

Consulta `{baseDir}/references/api.md` para obtener documentos completos de parámetros, campos opcionales y ejemplos de respuestas para todos los tipos de tarea.

Puntos clave:

• La bandera always: true asegura que esta habilidad se cargue en cada conversación — el agente siempre tiene los documentos de la API en contexto
• El campo requires verifica que node esté instalado y CAPSOLVER_API_KEY esté configurado
• La sección "Ejecución requerida" evita que el agente solo describa lo que haría — fuerza llamadas reales a herramientas

Referencia de API (references/api.md)

La habilidad también incluye una referencia completa de API que el agente puede leer a demanda para obtener documentos detallados de parámetros. Aquí lo que cubre:

reCAPTCHA v2

Parámetros requeridos: type, websiteURL, websiteKey

Parámetros opcionales: isInvisible (Booleano), pageAction (Cadena), recaptchaDataSValue (Cadena), enterprisePayload (Objeto), apiDomain (Cadena)

{
  "clientKey": "TU_API_KEY",
  "task": {
    "type": "ReCaptchaV2TaskProxyLess",
    "websiteURL": "https://www.google.com/recaptcha/api2/demo",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
    "isInvisible": false
  }
}

Token de respuesta: solution.gRecaptchaResponse → inyectar en textarea[name="g-recaptcha-response"]

reCAPTCHA v3

Parámetros requeridos: type, websiteURL, websiteKey

Parámetros opcionales: pageAction (Cadena — de grecaptcha.execute(key, {action: "..."}), valores comunes: login, submit, homepage), enterprisePayload (Objeto), apiDomain (Cadena)

{
  "clientKey": "TU_API_KEY",
  "task": {
    "type": "ReCaptchaV3TaskProxyLess",
    "websiteURL": "https://www.example.com",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-",
    "pageAction": "login"
  }
}

Token de respuesta: solution.gRecaptchaResponse → inyectar en textarea[name="g-recaptcha-response"]

Cloudflare Turnstile

Parámetros requeridos: type (AntiTurnstileTaskProxyLess), websiteURL, websiteKey

Parámetros opcionales: metadata.action (Cadena — de data-action attribute), metadata.cdata (Cadena — de data-cdata attribute)

{
  "clientKey": "TU_API_KEY",
  "task": {
    "type": "AntiTurnstileTaskProxyLess",
    "websiteURL": "https://www.example.com",
    "websiteKey": "0x4XXXXXXXXXXXXXXXXX",
    "metadata": {
      "action": "login",
      "cdata": "0000-1111-2222-3333-example-cdata"
    }
  }
}

Token de respuesta: solution.token → inyectar en input[name="cf-turnstile-response"]

Tiempos típicos de resolución

¿Cómo funciona?

Cuando le pides a Nanobot que interactúe con una página protegida por CAPTCHA, aquí es lo que sucede en segundo plano:

  Tu mensaje                    Agente de Nanobot
  ────────────────────────────────────────────────────
  "Ve a esa página,          ──►  El agente recibe el mensaje
   completa el formulario,                 │
   resuelve el CAPTCHA,                   ▼
   y envíalo"            El agente escribe el script de automatización
                                  │
                                  ▼
                             La herramienta exec ejecuta el script
                             ┌─────────────────────────────────┐
                             │  Chromium headless               │
                             │                                  │
                             │  1. Navegar a la página objetivo │
                             │  2. Extraer el sitekey del DOM   │
                             │     (atributo data-sitekey)     │
│                                  │
                             │  3. Llamar a la API de CapSolver:     │
                             │     POST /createTask             │
                             │     POST /getTaskResult (poll)   │
                             │                                  │
                             │  4. Inyectar el token en campos     │
                             │     de texto/entrada ocultos        │
                             │                                  │
                             │  5. Hacer clic en Enviar           │
                             │  6. Verificar el éxito              │
                             │  7. Tomar capturas de pantalla      │
                             └─────────────────────────────────┘
                                  │
                                  ▼
                             El agente lee la salida y las capturas de pantalla
                                  │
                                  ▼
                             "Formulario enviado correctamente!
                              La página muestra: Verificación
                              Éxito... ¡Hurra!"

El flujo de la API de CapSolver

El núcleo de la integración son dos llamadas a la API:

1. Crear una tarea — Enviar la clave del sitio CAPTCHA y la URL de la página a CapSolver:

const response = await fetch('https://api.capsolver.com/createTask', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    clientKey: CAPSOLVER_API_KEY,
    task: {
      type: 'ReCaptchaV2TaskProxyLess',
      websiteURL: pageUrl,
      websiteKey: siteKey
    }
  })
});

2. Consultar el resultado — Verificar cada 2 segundos hasta que CapSolver devuelva el token resuelto:

const result = await fetch('https://api.capsolver.com/getTaskResult', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    clientKey: CAPSOLVER_API_KEY,
    taskId: taskId
  })
});
// result.solution.gRecaptchaResponse contiene el token

3. Inyectar el token — Establecerlo en el campo oculto del formulario que espera reCAPTCHA:

await page.evaluate((token) => {
  const textarea = document.querySelector('textarea[name="g-recaptcha-response"]');
  if (textarea) {
    textarea.value = token;
    textarea.innerHTML = token;
  }
}, captchaToken);

Ejemplo de trabajo completo

Aquí está el script real que generó y ejecutó el agente de Nanobot para resolver reCAPTCHA en la página de demostración de Google. El agente lo escribió mediante write_file, luego lo ejecutó con exec — todo de forma autónoma desde un solo mensaje de Discord:

const { chromium } = require('playwright');
const https = require('https');

const CAPSOLVER_API_KEY = process.env.CAPSOLVER_API_KEY;
const PAGE_URL = 'https://www.google.com/recaptcha/api2/demo';

function httpsPost(url, data) {
  return new Promise((resolve, reject) => {
    const req = https.request(url, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' }
    }, (res) => {
      let body = '';
      res.on('data', chunk => body += chunk);
      res.on('end', () => resolve(JSON.parse(body)));
    });
    req.on('error', reject);
    req.write(JSON.stringify(data));
    req.end();
  });
}

async function solveRecaptcha(siteKey, pageUrl) {
  console.log('Creando tarea de Capsolver...');

  const createRes = await httpsPost('https://api.capsolver.com/createTask', {
    clientKey: CAPSOLVER_API_KEY,
    task: {
      type: 'ReCaptchaV2TaskProxyLess',
      websiteURL: pageUrl,
      websiteKey: siteKey
    }
  });

  const { taskId } = createRes;
  console.log(`ID de tarea: ${taskId}`);

  let token;
  while (true) {
    await new Promise(r => setTimeout(r, 2000));

    const res = await httpsPost('https://api.capsolver.com/getTaskResult', {
      clientKey: CAPSOLVER_API_KEY,
      taskId
    });

    if (res.status === 'ready') {
      token = res.solution.gRecaptchaResponse;
      console.log(`Token recibido! Longitud: ${token.length}`);
      break;
    }
    if (res.status === 'failed') {
      throw new Error('La tarea de Capsolver falló');
    }
  }

  if (!token) throw new Error('No se pudo obtener el token');
  return token;
}

async function main() {
  const browser = await chromium.launch({ headless: true });
  const page = await browser.newPage();

  console.log('Navegando a la página...');
  await page.goto(PAGE_URL, { waitUntil: 'domcontentloaded', timeout: 30000 });

  console.log('Extrayendo sitekey...');
  const siteKey = await page.locator('[data-sitekey]').getAttribute('data-sitekey');
  console.log(`Sitekey: ${siteKey}`);

  console.log('Resolviendo reCAPTCHA con Capsolver...');
  const token = await solveRecaptcha(siteKey, PAGE_URL);

  console.log('Inyectando token...');
  await page.evaluate((t) => {
    document.querySelectorAll('textarea[name="g-recaptcha-response"]')
      .forEach(el => { el.value = t; el.innerHTML = t; });
  }, token);

  console.log('Enviando formulario...');
  await page.locator('input[type="submit"]').click();

  console.log('Esperando resultado...');
  await page.waitForTimeout(3000);

  const successText = await page.textContent('body');
  if (successText.includes('Éxito') || successText.includes('Verificación')) {
    console.log('\n✅ ÉXITO! reCAPTCHA resuelto y formulario enviado correctamente!');
    console.log('Mensaje de éxito:', successText.slice(0, 200));
  } else {
    console.log('\n❌ Resultado no claro. Contenido de la página:', successText.slice(0, 300));
  }

  await page.screenshot({ path: 'recaptcha_result.png' });
  console.log('Captura de pantalla guardada en recaptcha_result.png');

  await browser.close();
}

main().catch(console.error);

Ejecutarlo:

CAPSOLVER_API_KEY=CAP-XXX node solve_recaptcha.js

Cómo usarlo con Nanobot

Una vez que la configuración esté completa, usar CapSolver con Nanobot es tan simple como enviar un mensaje.

Ejemplo 1: Resolver un reCAPTCHA de demostración

Envía esto a tu agente mediante Telegram, Discord, WhatsApp o cualquier canal conectado:

Ve a https://www.google.com/recaptcha/api2/demo y resuelve
el reCAPTCHA usando la API de CapSolver, luego envía el formulario
y dime si tuvo éxito.

Lo que sucede:

1. El agente escribe un script de Playwright
2. El script navega a la página y extrae la clave de reCAPTCHA del DOM
3. Llama a la API createTask de CapSolver con la clave
4. Consulta getTaskResult cada 2 segundos hasta que el token esté listo (~18 segundos)
5. Inyecta el token en el campo oculto g-recaptcha-response
6. Hace clic en Enviar y verifica el éxito
7. El agente informa: "Formulario enviado correctamente! La página muestra: Verificación Éxito... ¡Hurra!"

Ejemplo 2: Iniciar sesión en un sitio protegido

Ve a https://example.com/login, completa el correo electrónico con
"[email protected]" y la contraseña con "mypassword", detecta y
resuelve cualquier CAPTCHA en la página, luego haz clic en Iniciar sesión y dime
qué pasa.

Ejemplo 3: Enviar un formulario de contacto

Abre https://example.com/contacto, completa los campos de nombre, correo electrónico y
mensaje, resuelve el CAPTCHA, envía el formulario y dime el mensaje de confirmación.

Por qué esto funciona

Porque el agente de Nanobot tiene:

• Herramienta exec — ejecuta cualquier comando de shell, incluidos scripts de Node.js
• Herramienta web_fetch — obtiene el contenido de la página para entender la estructura de la página
• Herramientas de archivo — puede escribir, editar y leer scripts de automatización
• Memoria — recuerda los enfoques funcionales para tareas futuras
• Habilidad integrada capsolver — siempre cargada en el contexto del agente (ver La habilidad integrada de CapSolver anterior), incluye tipos de tarea, patrones de código, referencia de API y instrucciones de ejecución que aseguran que el agente escriba y ejecute scripts en lugar de solo describir lo que haría

Reinicio de alucinaciones: Asegurar que el agente actúe

Un desafío con agentes impulsados por LLM es que algunos modelos responden con texto como "Ejecutando la automatización ahora..." sin llamar a ninguna herramienta. El usuario ve un mensaje que parece progreso, pero nada ocurre en segundo plano.

Nanobot resuelve esto con un mecanismo de reinicio de alucinaciones integrado en el ciclo del agente. Cuando la LLM responde con texto en su primera iteración y ese texto contiene frases de acción como "ejecutando ahora", "he comenzado", o "ejecutando ahora" — pero no hizo llamadas a herramientas — Nanobot lo detecta y envía automáticamente un mensaje de corrección:

"Describiste que iniciaste una tarea pero no llamaste a ninguna herramienta. El usuario no puede ver tu progreso a menos que uses herramientas como exec, write_file o spawn. Por favor, llama a la herramienta correspondiente ahora."

La LLM vuelve a intentarlo y llama a la herramienta real (por ejemplo, spawn para lanzar una tarea de automatización en segundo plano). Esto ocurre de forma transparente — el usuario solo ve los resultados llegar unos segundos después.

Esto es una característica general de Nanobot que mejora la confiabilidad para todas las tareas que usan herramientas, no solo para resolver CAPTCHAs.

Cambios de código recomendados

Para habilitar el reinicio de alucinaciones y otras mejoras de confiabilidad, aplique estos tres cambios en su instalación de Nanobot:

1. Reinicio de alucinaciones (nanobot/agent/loop.py)

En el método _process_message, reemplace la rama else que maneja respuestas sin llamadas a herramientas:

            else:
                # Sin llamadas a herramientas — pero comprueba si la LLM alucinó una acción
                if iteration == 1 and self._seems_like_hallucinated_action(response.content):
                    logger.warning("La LLM describió una acción sin llamadas a herramientas — reintentando con corrección")
                    messages.append({"role": "assistant", "content": response.content})
                    messages.append({
                        "role": "user",
                        "content": (
                            "[Sistema: Describiste que iniciaste una tarea pero no llamaste a ninguna herramienta. "
                            "El usuario no puede ver tu progreso a menos que uses herramientas como exec, "
                            "write_file o spawn. Por favor, llama a la herramienta correspondiente ahora para "
                            "realizar realmente la tarea.]"
                        ),
                    })
                    continue
                final_content = response.content
                break

Y agregue este método de detección a la clase AgentLoop:

    @staticmethod
    def _seems_like_hallucinated_action(content: str | None) -> bool:
        """Detectar si la LLM describió iniciar una acción sin llamar herramientas."""
        if not content:
            return False
        lower = content.lower()
        frases = [
            "ejecutando ahora", "he comenzado", "comenzaré", "iniciando la",
            "he empezado", "comenzaré", "ejecutando ahora", "estoy trabajando en",
            "déjame ejecutar", "ejecutando la", "he lanzado", "lanzada la",
            "he iniciado", "trabajando en ello",
        ]
        return any(frase in lower for frase in frases)

2. Habilidades en subagentes (nanobot/agent/subagent.py)

Sin este cambio, los subagentes lanzados mediante la herramienta spawn no tienen la habilidad de capsolver en su contexto. Agregue la importación y inyecte siempre las habilidades cargadas en el prompt del subagente:

# Agregar importación
from nanobot.agent.skills import SkillsLoader

# En __init__, agregar:
self._skills = SkillsLoader(workspace)

# Al final de _build_subagent_prompt(), antes de return:
        siempre_habilidades = self._skills.get_always_skills()
        if siempre_habilidades:
            contenido_habilidades = self._skills.load_skills_for_context(siempre_habilidades)
            if contenido_habilidades:
                prompt += f"\n\n## Documentación de referencia\n\n{contenido_habilidades}"
        return prompt

3. Tiempo de ejecución (nanobot/config/schema.py)

Los scripts de automatización de navegador necesitan más de los 60 segundos predeterminados — el polling de CapSolver solo puede tomar 20+ segundos. Aumente el tiempo de espera:

class ExecToolConfig(BaseModel):
    """Configuración de la herramienta de ejecución de shell."""
    timeout: int = 120  # era 60

Después de aplicar estos cambios, reinicie Nanobot (pm2 restart nanobot o reinicie el servicio).

Resultados de rendimiento

Probamos la integración en la página de demostración de reCAPTCHA v2 de Google. Aquí están los resultados reales de nuestra ejecución de prueba:

El agente guardó una captura de pantalla final (recaptcha_result.png) mostrando la página de éxito después del envío del formulario.

Solución de problemas

"No se puede encontrar el módulo 'playwright'"

Playwright no está instalado en el espacio de trabajo. Ejecute:

cd ~/.nanobot/workspace && npm install playwright && npx playwright install chromium

Bibliotecas de navegador faltantes en Ubuntu

Si Chromium falla al iniciar con errores sobre bibliotecas compartidas faltantes, instale las dependencias del sistema:

sudo apt install -y libnss3 libatk-bridge2.0-0 libdrm2 libxcomposite1 \
  libxdamage1 libxrandr2 libgbm1 libpango-1.0-0 libasound2t64

Tiempo de espera para resolver CAPTCHA

• Verifique que su clave de API de CapSolver sea válida
• Verifique su saldo en CapSolver en capsolver.com/dashboard
• El script consulta cada 2 segundos hasta que CapSolver devuelva ready o failed — si se queda colgado, verifique su clave de API y saldo

No se encuentra el sitekey

El script extrae el sitekey del atributo data-sitekey en el elemento DOM de reCAPTCHA. Si no se encuentra ningún elemento con data-sitekey, la página podría integrar la clave de forma diferente — el agente puede escribir un script modificado para extraerla de las URLs de iframes o de la fuente de la página según sea necesario.

El navegador se cae en Docker/contenedores

Agregue estas banderas a las opciones de lanzamiento de Playwright:

chromium.launch({
  headless: true,
  args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage']
});

El agente no usa CapSolver

Asegúrese de que la variable de entorno CAPSOLVER_API_KEY esté definida antes de iniciar Nanobot. El agente la verifica en tiempo de ejecución.

Mejores prácticas

1. Establezca la clave API como variable de entorno

No codifique la clave en los scripts. Use process.env.CAPSOLVER_API_KEY para que el agente la reciba automáticamente.

2. Use el modo sin cabeza en servidores

La aproximación basada en API de Nanobot funciona en entornos completamente sin cabeza — no se necesita Xvfb o visualización virtual. Esta es una ventaja significativa frente a enfoques basados en extensiones.

3. Monitoree su saldo en CapSolver

Cada resolución de CAPTCHA cuesta créditos. Verifica tu saldo en capsolver.com/dashboard con regularidad.

4. Mantén a Playwright actualizado

Los proveedores de CAPTCHA evolucionan. Mantén actualizado Playwright y Chromium para evitar problemas de detección:

cd ~/.nanobot/workspace && npm update playwright && npx playwright install chromium

Conclusión

La integración de Nanobot + CapSolver toma un enfoque fundamentalmente diferente al de resolver CAPTCHA con extensiones. En lugar de cargar una extensión de Chrome, el agente de IA coordina todo el proceso de resolución:

1. Navegar a la página objetivo con Playwright
2. Extraer el sitekey de la atributo data-sitekey
3. Resolver llamando directamente a la API REST de CapSolver
4. Inyectar el token de solución en el campo oculto del formulario
5. Enviar el formulario y verificar el éxito

Esto te da:

• Sin dependencia de extensión de Chrome — funciona con cualquier navegador headless
• Soporte para servidor headless — no se necesita visualización o Xvfb
• Control por lenguaje natural — solo diles al agente lo que quieres que haga

¿Listo para comenzar? Regístrate en CapSolver y usa el código de bonificación NANOBOT para un bono adicional del 6% en tu primer recarga!

Preguntas frecuentes

¿Cómo resuelve Nanobot las CAPTCHAs de manera diferente a las extensiones del navegador?

Nanobot utiliza directamente la API REST de CapSolver. El agente escribe y ejecuta scripts que llaman a createTask y getTaskResult para obtener tokens de solución, luego los inyecta en el DOM de la página. No se necesita ninguna extensión de navegador.

¿Necesito una versión especial de Chrome?

No. A diferencia de los enfoques basados en extensiones que requieren Chrome para pruebas (ya que Chrome 137+ deshabilitó la carga de extensiones), Nanobot funciona con cualquier construcción de Chromium — incluyendo el Chromium empaquetado por Playwright, paquetes estándar de Chromium o incluso Chrome headless.

¿Qué tipos de CAPTCHA soporta CapSolver?

CapSolver soporta reCAPTCHA v2 (casilla e invisible), reCAPTCHA v3, Cloudflare Turnstile, AWS WAF CAPTCHA y más. Probamos la integración de Nanobot con reCAPTCHA v2 usando el tipo de tarea ReCaptchaV2TaskProxyLess. Para otros tipos de CAPTCHA, el agente puede escribir un script usando el tipo de tarea adecuado de CapSolver — consulta la documentación de CapSolver para ver la lista completa.

¿Puedo usar esto en un servidor headless?

Sí — y es donde el enfoque de Nanobot brilla. Como no hay extensión de navegador involucrada, no necesitas Xvfb o una pantalla virtual. Playwright funciona en modo completamente headless de forma predeterminada.

¿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 Nanobot gratis?

Nanobot es de código abierto y gratuito para ejecutar en tu propio hardware. Necesitarás claves de API para el proveedor de modelos de IA de tu elección y, para resolver CAPTCHA, una cuenta de CapSolver con créditos.

¿Cuánto tiempo tarda en resolver CAPTCHA?

En nuestra prueba con reCAPTCHA v2, la API de CapSolver devolvió la solución en ~20 segundos. El agente consulta cada 2 segundos y continúa tan pronto como el token esté listo. El tiempo total de ejecución del script (navegar + resolver + inyectar + enviar) fue de ~34 segundos, y el tiempo total desde el mensaje hasta la respuesta fue de ~45 segundos incluyendo la escritura del script por parte del agente.