Como resolver Captcha no RoxyBrowser com integração do CapSolver

O RoxyBrowser fornece funcionalidade de navegador por meio de chamadas de API e pode ser integrado com frameworks de automação como Selenium, Puppeteer e Playwright. Sua API foi projetada para permitir que você abra perfis de navegador reais de forma programática e anexe suas ferramentas de automação. A API tem um limite de taxa documentado de 100 chamadas por minuto por ponto de extremidade.
Fonte: https://faq.roxybrowser.org/en/guide/10-API

O CapSolver fornece um fluxo de API de criação e verificação que retorna um token CAPTCHA que você pode injetar na página. O CapSolver suporta vários tipos de CAPTCHA:

• reCAPTCHA v2: Tipo de tarefa ReCaptchaV2TaskProxyLess, retorna gRecaptchaResponse
• reCAPTCHA v3: Tipo de tarefa ReCaptchaV3TaskProxyLess, retorna gRecaptchaResponse com pontuação
• Cloudflare Turnstile: Tipo de tarefa AntiTurnstileTaskProxyLess, retorna token Consulte as docs

Este guia mostra um fluxo prático e independente de framework: abra um perfil do Roxy via API, anexe seu framework de automação, resolva o CAPTCHA com o CapSolver e injete o token para continuar.

O que é o RoxyBrowser?

RoxyBrowser é um navegador antidetect para multi-contas com recursos como automação via API e sincronizador de janelas múltiplas.

Para automação, a API é a parte mais relevante:

• Suporta integração com Selenium, Puppeteer e Playwright.

• As solicitações devem incluir um cabeçalho token.

• O host padrão da API é http://127.0.0.1:50000 (a alteração da porta requer reinicialização).

O que é o CapSolver?

O CapSolver resolve CAPTCHAs por meio de duas chamadas de API:

1. createTask para enviar os parâmetros do CAPTCHA
2. getTaskResult para verificar até que o token esteja pronto

Para reCAPTCHA v2, o CapSolver retorna gRecaptchaResponse.

getTaskResult é limitado a 120 consultas por tarefa e deve ser chamado dentro de 5 minutos da criação da tarefa.

Configuração da API do RoxyBrowser

1) Ative a API e obtenha seu token

1. Abra o RoxyBrowser e vá para API.
2. Defina o interruptor de API para Habilitado.
3. Copie a chave de API (token) e confirme o host/porta.

Por padrão, o host é http://127.0.0.1:50000. Se você alterar a porta, será necessário reiniciar o RoxyBrowser.

2) Obtenha os IDs do workspace e perfil

Use /browser/workspace para buscar workspaces, depois /browser/list_v3 para listar perfis.

import requests

BASE = "http://127.0.0.1:50000"
HEADERS = {"token": "SUA_CHAVE_API_DO_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) Abra um perfil e capture os endpoints de automação

Chame /browser/open. A resposta inclui:

• ws: Interface WebSocket para ferramentas de automação
• http: Interface HTTP para ferramentas de automação
• driver: Caminho do WebDriver para integração com Selenium

O modo headless não é suportado.

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) Anexe seu framework de automação

Use os endpoints retornados para anexar seu framework:

• Puppeteer/Playwright podem se conectar via WebSocket DevTools ou endpoint HTTP.
• Selenium pode usar o caminho driver com uma conexão do debugger.

Os passos exatos para anexar dependem do seu framework, mas os valores ws, http e driver são explicitamente fornecidos para ferramentas de automação.

Helper do CapSolver (Python)

import time
import requests

CAPSOLVER_API_KEY = "SUA_CHAVE_API_DO_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", "Erro no 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", "Tarefa falhou"))

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
    }
    # Adicione metadados adicionais se fornecidos
    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 referência:

• reCAPTCHA v2
• reCAPTCHA v3
• Turnstile

Fluxo Completo: reCAPTCHA v2

1. Abra um perfil do Roxy via /browser/open e anexe seu framework de automação.

2. Navegue até a página de destino e extraia a chave do site.
   Exemplo:

   javascript Copy

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

3. Resolva com o CapSolver usando o helper acima.

4. Injete o token e envie o formulário:

   javascript Copy

   const token = "TOKEN_DO_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 }));

Fluxo Completo: reCAPTCHA v3

A reCAPTCHA v3 funciona de forma diferente - ela roda em segundo plano e retorna uma pontuação (0,0 a 1,0) em vez de exigir interação do usuário.

1. Extraia a chave do site e a ação da página:

   javascript Copy

   // A chave do site geralmente está em um script ou tag meta
   const siteKey = document.querySelector('[data-sitekey]')?.getAttribute('data-sitekey');
   
   // A ação é encontrada em chamadas grecaptcha.execute
   // Procure no código da página por: grecaptcha.execute('CHAVE', {action: 'AÇÃO'})
   const pageAction = "submit"; // ou "login", "registro", etc.

2. Resolva com o CapSolver:

   python Copy

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

3. Injete o token (mesmo processo do v2):

   javascript Copy

   const token = "TOKEN_DO_CAPSOLVER";
   document.getElementById("g-recaptcha-response").value = token;
   
   // Se houver um callback, invoque-o
   if (typeof ___grecaptcha_cfg !== 'undefined') {
       const clients = ___grecaptcha_cfg.clients;
       Object.keys(clients).forEach(key => {
           if (clients[key].callback) {
               clients[key].callback(token);
           }
       });
   }

Fluxo Completo: Cloudflare Turnstile

O Cloudflare Turnstile é uma alternativa moderna de CAPTCHA que é mais rápida de resolver (1-20 segundos).

1. Extraia a chave do site do Turnstile:

   javascript Copy

   const siteKey = document.querySelector('.cf-turnstile')?.getAttribute('data-sitekey');
   // Opcional: extraia a ação e cdata se presentes
   const action = document.querySelector('.cf-turnstile')?.getAttribute('data-action');
   const cdata = document.querySelector('.cf-turnstile')?.getAttribute('data-cdata');

2. Resolva com o CapSolver:

   python Copy

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

3. Injete o token do Turnstile:

   javascript Copy

   const token = "TOKEN_DO_CAPSOLVER_TURNSTILE";
   
   // Encontre o campo de resposta do 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: alguns sites usam um nome de entrada diferente
   const altInput = document.querySelector('input[name="turnstile-response"]');
   if (altInput) {
       altInput.value = token;
   }

Boas Práticas

• Respeite o limite de taxa da API do RoxyBrowser: 100 chamadas por minuto por ponto de extremidade.
• O getTaskResult do CapSolver é limitado a 120 verificações dentro de 5 minutos.
• Use lógica de repetição e backoff se os tokens forem rejeitados.
• Mantenha o IP do solver e o IP de navegação consistentes quando o site alvo validar a origem do token.

Pronto para começar? Registre-se no CapSolver e use o código de bônus ROXYBROWSER para obter um bônus adicional de 6% na sua primeira recarga!

Perguntas Frequentes

• O RoxyBrowser suporta Selenium, Puppeteer e Playwright?
  Sim. A API foi projetada para integração com esses frameworks.

• Onde obtenho o token e o host da API?
  Em API -> Configuração da API no RoxyBrowser. O host padrão é http://127.0.0.1:50000.

• O que o /browser/open retorna?
  Retorna os campos ws, http e driver usados pelas ferramentas de automação.

• O modo headless é suportado?
  Não, o modo headless não é suportado.

• Quais tipos de CAPTCHA o CapSolver suporta?

  • reCAPTCHA v2 (baseado em imagem e invisível)
  • reCAPTCHA v3 e v3 Enterprise
  • Cloudflare Turnstile
  • Cloudflare 5-second Challenge
  • AWS WAF CAPTCHA
  • Outros mecanismos de anti-bot amplamente usados

• Como o CapSolver retorna tokens reCAPTCHA v2?
  Crie uma tarefa com ReCaptchaV2TaskProxyLess e verifique getTaskResult para gRecaptchaResponse.

• Como o reCAPTCHA v3 difere do v2?
  A reCAPTCHA v3 roda em segundo plano sem interação do usuário e retorna uma pontuação (0,0-1,0). Ela requer o parâmetro pageAction, que pode ser encontrado procurando por grecaptcha.execute no código da página.

• Como resolver o Cloudflare Turnstile?](https://www.capsolver.com/blog/Cloudflare/solver-cloudflare-challenge-turnstile-2024)
  Use o tipo de tarefa AntiTurnstileTaskProxyLess com websiteURL e websiteKey. Opcionalmente inclua metadata.action e metadata.cdata se presentes no widget. O Turnstile é resolvido em 1-20 segundos.
  Leitura adicional:

• Como encontrar a chave do site do Turnstile?
  Procure pelo atributo data-sitekey no elemento .cf-turnstile. As chaves do Turnstile começam com 0x4.

• Preciso de um proxy para o CapSolver?
  Não, os tipos de tarefa *ProxyLess usam a infraestrutura de proxy interna do CapSolver. Use as variantes sem ProxyLess se precisar usar seus próprios proxies.

Conclusão

O RoxyBrowser fornece um ambiente de navegador baseado em perfis com endpoints de automação, e o CapSolver fornece tokens CAPTCHA programáticos. Ao abrir um perfil do Roxy, anexar seu framework e injetar tokens do CapSolver, você pode construir fluxos de automação confiáveis com CAPTCHA.