Cómo resolver un Captcha en RoxyBrowser con la integración de CapSolver

RoxyBrowser proporciona funcionalidad de navegador mediante llamadas a la API y se puede integrar con marcos de automatización como Selenium, Puppeteer y Playwright. Su API está diseñada para permitirle abrir perfiles de navegador reales de forma programática y adjuntar su herramienta de automatización. La API tiene un límite de tasa documentado de 100 llamadas por minuto por endpoint.
Fuente: https://faq.roxybrowser.org/en/guide/10-API

CapSolver proporciona un flujo de API de creación y encuesta que devuelve un token de CAPTCHA que puede inyectar en la página. CapSolver admite varios tipos de CAPTCHA:

• reCAPTCHA v2: Tipo de tarea ReCaptchaV2TaskProxyLess, devuelve gRecaptchaResponse
• reCAPTCHA v3: Tipo de tarea ReCaptchaV3TaskProxyLess, devuelve gRecaptchaResponse con puntuación
• Cloudflare Turnstile: Tipo de tarea AntiTurnstileTaskProxyLess, devuelve token Consulte la documentación

Este guía muestra un flujo práctico y no vinculado a un marco: abrir un perfil de Roxy mediante API, adjuntar su marco de automatización, resolver la CAPTCHA con CapSolver y inyectar el token para continuar.

¿Qué es RoxyBrowser?

RoxyBrowser es un navegador antidetect para múltiples cuentas con funciones como automatización por API y sincronizador de múltiples ventanas.

Para la automatización, la API es la pieza más relevante:

• Soporta integración con Selenium, Puppeteer y Playwright.

• Las solicitudes deben incluir un encabezado token.

• La host de API predeterminada es http://127.0.0.1:50000 (cambiar el puerto requiere reiniciar).

¿Qué es CapSolver?

CapSolver resuelve CAPTCHAS mediante dos llamadas a la API:

1. createTask para enviar los parámetros de la CAPTCHA
2. getTaskResult para encuestar hasta que el token esté listo

Para reCAPTCHA v2, CapSolver devuelve gRecaptchaResponse.

getTaskResult está limitado a 120 consultas por tarea y debe llamarse dentro de los 5 minutos de la creación de la tarea.

Configuración de la API de RoxyBrowser

1) Habilitar la API y obtener su token

1. Abra RoxyBrowser y vaya a API.
2. Establezca el interruptor de API en Habilitado.
3. Copie la clave de API (token) y confirme la host/puerto.

Por defecto, la host es http://127.0.0.1:50000. Si cambia el puerto, debe reiniciar RoxyBrowser.

2) Obtener IDs de workspace y perfiles

Use /browser/workspace para obtener workspaces, luego /browser/list_v3 para listar perfiles.

import requests

BASE = "http://127.0.0.1:50000"
HEADERS = {"token": "SU_CLAVE_DE_API_DE_ROXY"}

workspaces = requests.get(f"{BASE}/browser/workspace", headers=HEADERS).json()
workspace_id = workspaces["data"]["rows"][0]["id"]

profiles = requests.get(
    f"{BASE}/browser/list_v3",
    params={"workspaceId": workspace_id},
    headers=HEADERS
).json()
dir_id = profiles["data"]["rows"][0]["dirId"]

3) Abrir un perfil y capturar los puntos de conexión de automatización

Llame a /browser/open. La respuesta incluye:

• ws: interfaz WebSocket para herramientas de automatización
• http: interfaz HTTP para herramientas de automatización
• driver: ruta WebDriver para integración con Selenium

No se admite el modo headless.

open_resp = requests.post(
    f"{BASE}/browser/open",
    json={"workspaceId": workspace_id, "dirId": dir_id, "args": []},
    headers=HEADERS
).json()

ws_endpoint = open_resp["data"]["ws"]
http_endpoint = open_resp["data"]["http"]
driver_path = open_resp["data"]["driver"]

4) Adjuntar su marco de automatización

Use los puntos de conexión devueltos para adjuntar su marco:

• Puppeteer/Playwright pueden conectarse mediante el WebSocket DevTools o el punto de conexión HTTP.
• Selenium puede usar la ruta driver con una conexión de depurador.

Los pasos exactos para adjuntar dependen de su marco, pero los valores ws, http y driver se proporcionan explícitamente para herramientas de automatización.

Ayudante de CapSolver (Python)

import time
import requests

CAPSOLVER_API_KEY = "SU_CLAVE_DE_API_DE_CAPSOLVER"
CAPSOLVER_BASE = "https://api.capsolver.com"

def create_task(task):
    payload = {"clientKey": CAPSOLVER_API_KEY, "task": task}
    r = requests.post(f"{CAPSOLVER_BASE}/createTask", json=payload)
    data = r.json()
    if data.get("errorId", 0) != 0:
        raise RuntimeError(data.get("errorDescription", "Error de CapSolver"))
    return data["taskId"]

def get_task_result(task_id, delay=2):
    while True:
        time.sleep(delay)
        r = requests.post(
            f"{CAPSOLVER_BASE}/getTaskResult",
            json={"clientKey": CAPSOLVER_API_KEY, "taskId": task_id}
        )
        data = r.json()
        if data.get("status") == "ready":
            return data["solution"]
        if data.get("status") == "failed":
            raise RuntimeError(data.get("errorDescription", "Tarea fallida"))

def solve_recaptcha_v2(website_url, website_key):
    task = {
        "type": "ReCaptchaV2TaskProxyLess",
        "websiteURL": website_url,
        "websiteKey": website_key
    }
    task_id = create_task(task)
    solution = get_task_result(task_id)
    return solution.get("gRecaptchaResponse", "")

def solve_recaptcha_v3(website_url, website_key, page_action="verify"):
    task = {
        "type": "ReCaptchaV3TaskProxyLess",
        "websiteURL": website_url,
        "websiteKey": website_key,
        "pageAction": page_action
    }
    task_id = create_task(task)
    solution = get_task_result(task_id)
    return solution.get("gRecaptchaResponse", "")

def solve_turnstile(website_url, website_key, action=None, cdata=None):
    task = {
        "type": "AntiTurnstileTaskProxyLess",
        "websiteURL": website_url,
        "websiteKey": website_key
    }
    # Añadir metadatos adicionales si se proporcionan
    if action or cdata:
        task["metadata"] = {}
        if action:
            task["metadata"]["action"] = action
        if cdata:
            task["metadata"]["cdata"] = cdata

    task_id = create_task(task)
    solution = get_task_result(task_id)
    return solution.get("token", "")

Para referencia:

• reCAPTCHA v2
• reCAPTCHA v3
• Turnstile

Flujo de extremo a extremo: reCAPTCHA v2

1. Abrir un perfil de Roxy mediante /browser/open y adjuntar su marco de automatización.

2. Navegar a la página objetivo y extraer la clave del sitio.
   Ejemplo:

   javascript Copy

   const siteKey = document.querySelector(".g-recaptcha")?.getAttribute("data-sitekey");

3. Resolver con CapSolver usando el ayudante anterior.

4. Inyectar el token y enviar el formulario:

   javascript Copy

   const token = "TOKEN_DE_CAPSOLVER";
   const el = document.getElementById("g-recaptcha-response");
   el.style.display = "block";
   el.value = token;
   el.dispatchEvent(new Event("input", { bubbles: true }));
   el.dispatchEvent(new Event("change", { bubbles: true }));

Flujo de extremo a extremo: reCAPTCHA v3

reCAPTCHA v3 funciona de manera diferente: funciona en segundo plano y devuelve una puntuación (0,0 a 1,0) en lugar de requerir interacción del usuario.

1. Extraer la clave del sitio y la acción de la página:

   javascript Copy

   // La clave del sitio suele estar en un script o etiqueta meta
   const siteKey = document.querySelector('[data-sitekey]')?.getAttribute('data-sitekey');
   
   // La acción se encuentra en llamadas a grecaptcha.execute
   // Buscar en el código fuente de la página: grecaptcha.execute('KEY', {action: 'ACTION'})
   const pageAction = "submit"; // o "login", "register", etc.

2. Resolver con CapSolver:

   python Copy

   token = solve_recaptcha_v3(
       website_url="https://example.com/login",
       website_key="6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxAA",
       page_action="login"
   )

3. Inyectar el token (igual que en v2):

   javascript Copy

   const token = "CAPSOLVER_TOKEN";
   document.getElementById("g-recaptcha-response").value = token;
   
   // Si hay una función de devolución, activarla
   if (typeof ___grecaptcha_cfg !== 'undefined') {
       const clients = ___grecaptcha_cfg.clients;
       Object.keys(clients).forEach(key => {
           if (clients[key].callback) {
               clients[key].callback(token);
           }
       });
   }

Flujo de extremo a extremo: Cloudflare Turnstile

Cloudflare Turnstile es una alternativa moderna a la CAPTCHA que es más rápida de resolver (1-20 segundos).

1. Extraer la clave del sitio de Turnstile:

   javascript Copy

   const siteKey = document.querySelector('.cf-turnstile')?.getAttribute('data-sitekey');
   // Opcional: extraer acción y cdata si están presentes
   const action = document.querySelector('.cf-turnstile')?.getAttribute('data-action');
   const cdata = document.querySelector('.cf-turnstile')?.getAttribute('data-cdata');

2. Resolver con CapSolver:

   python Copy

   token = solve_turnstile(
       website_url="https://example.com",
       website_key="0x4AAAAAAAxxxxxxxxxxxxxxx",
       action=action,  # opcional
       cdata=cdata     # opcional
   )

3. Inyectar el token de Turnstile:

   javascript Copy

   const token = "TOKEN_DE_TURNSTILE_DE_CAPSOLVER";
   
   // Encontrar el campo de respuesta de Turnstile
   const input = document.querySelector('input[name="cf-turnstile-response"]');
   if (input) {
       input.value = token;
       input.dispatchEvent(new Event('input', { bubbles: true }));
       input.dispatchEvent(new Event('change', { bubbles: true }));
   }
   
   // Alternativa: algunas páginas usan un nombre de campo diferente
   const altInput = document.querySelector('input[name="turnstile-response"]');
   if (altInput) {
       altInput.value = token;
   }

Mejores prácticas

• Respete el límite de tasa de la API de RoxyBrowser: 100 llamadas por minuto por endpoint.
• getTaskResult de CapSolver está limitado a 120 encuestas dentro de los 5 minutos.
• Use lógica de reintentos y retroceso si los tokens son rechazados.
• Mantenga la IP del solucionador y la IP de navegación consistentes cuando el sitio objetivo valide el origen del token.

¿Listo para comenzar? Regístrese en CapSolver y use el código de bonificación ROXYBROWSER para obtener un 6% adicional en su primer recarga!

Preguntas frecuentes

• ¿Soporta RoxyBrowser Selenium, Puppeteer y Playwright?
  Sí. La API está diseñada para integrarse con estos marcos.

• ¿Dónde obtengo el token de API y la host?
  Desde API -> Configuración de API en RoxyBrowser. La host predeterminada es http://127.0.0.1:50000.

• ¿Qué devuelve /browser/open?
  Devuelve los campos ws, http y driver utilizados por las herramientas de automatización.

• ¿Se admite el modo headless?
  No, el modo headless no se admite.

• ¿Qué tipos de CAPTCHA admite CapSolver?

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

• ¿Cómo devuelve CapSolver los tokens de reCAPTCHA v2?
  Cree una tarea con ReCaptchaV2TaskProxyLess y encueste getTaskResult para obtener gRecaptchaResponse.

• ¿En qué se diferencia reCAPTCHA v3 de v2?](https://www.capsolver.com/blog/reCAPTCHA/extra-parameters-recaptcha)
  reCAPTCHA v3 funciona en segundo plano sin interacción del usuario y devuelve una puntuación (0,0-1,0). Requiere el parámetro pageAction, que se puede encontrar buscando grecaptcha.execute en el código fuente de la página.

• ¿Cómo resuelvo Cloudflare Turnstile?](https://www.capsolver.com/blog/Cloudflare/solver-cloudflare-challenge-turnstile-2024)
  Use el tipo de tarea AntiTurnstileTaskProxyLess con websiteURL y websiteKey. Opcionalmente incluya metadata.action y metadata.cdata si están presentes en el widget. Turnstile se resuelve en 1-20 segundos.
  Lectura adicional:

• ¿Cómo encuentro la clave del sitio de Turnstile?
  Busque el atributo data-sitekey en el elemento .cf-turnstile. Las claves de sitio de Turnstile comienzan con 0x4.

• ¿Necesito un proxy para CapSolver?
  No, los tipos de tarea *ProxyLess utilizan la infraestructura de proxy integrada de CapSolver. Use las variantes sin ProxyLess si necesita usar sus propios proxies.

Conclusión

RoxyBrowser le da un entorno de navegador basado en perfiles con puntos de conexión de automatización, y CapSolver proporciona tokens de CAPTCHA programáticos. Al abrir un perfil de Roxy, adjuntar su marco y inyectar tokens de CapSolver, puede construir flujos de automatización confiables que tengan en cuenta las CAPTCHAS.