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

EasySpider é uma ferramenta poderosa de raspagem de web visual que permite a qualquer pessoa projetar e executar tarefas de automação do navegador sem escrever código. Sua interface baseada em fluxograma intuitiva torna-a acessível a não programadores, enquanto ainda oferece capacidades avançadas para desenvolvedores.

CapSolver completa a experiência de automação do EasySpider fornecendo resolução de CAPTCHA sem empecilhos. Embora o EasySpider suporte vários esquemas de reconhecimento de CAPTCHA, integrar as soluções baseadas em IA do CapSolver garante uma superação confiável, rápida de desafios de reCAPTCHA, Cloudflare Turnstile e outros CAPTCHAs.

O que é EasySpider?

EasySpider é uma ferramenta de raspagem de web e automação de navegador gratuita e de código aberto. Ao contrário de bibliotecas de raspagem tradicionais que exigem conhecimento de programação, o EasySpider permite que você projete tarefas visualmente apontando e clicando em elementos da web.

Filosofia Central

O EasySpider opera com três princípios fundamentais:

1. Design Primário Visual: Crie fluxos de automação complexos por meio de uma interface de fluxograma intuitiva
2. Acessibilidade sem Código: Projete tarefas tão facilmente quanto usar o Excel, independentemente da experiência em programação
3. Extensibilidade Total: Execute código JavaScript, Python e instruções Selenium quando necessário

Principais Funcionalidades do EasySpider

• Designer de Tarefas Visual: Interface de clique e arraste para criar fluxos de automação
• Multiplataforma: Disponível para Windows, macOS e Linux
• Modo Headless: Execute tarefas sem uma janela de navegador visível
• Execução de Código Personalizado: Execute código JavaScript e Python dentro dos fluxos
• Integração com Selenium: Manipulação direta do navegador usando instruções Selenium
• Invocação de API: Chame sistemas e serviços externos
• Execução por Linha de Comando: Execute tarefas programaticamente via CLI
• Tarefas Agendadas: Automatize a coleta de dados recorrente

Funcionalidades de Fluxo

O que é CapSolver?

CapSolver é um serviço líder de resolução de CAPTCHA que fornece soluções baseadas em IA para superar diversos desafios de CAPTCHA. Com suporte para vários tipos de CAPTCHA e tempos de resposta rápidos, o CapSolver se integra sem problemas em fluxos automatizados.

Tipos de CAPTCHA Suportados

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

Por que Integrar o CapSolver com o EasySpider?

Embora o EasySpider ofereça suporte integrado a CAPTCHA, integrar o CapSolver oferece vantagens significativas:

1. Taxas de Sucesso Mais Altas: As soluções baseadas em IA do CapSolver atingem taxas consistentes de sucesso
2. Resolução Mais Rápida: Infraestrutura otimizada que fornece tokens rapidamente
3. Cobertura Mais Amplia: Suporte para todos os principais tipos de CAPTCHA
4. Confiabilidade: Serviço de nível corporativo com excelente tempo de atividade
5. Escalabilidade: Trate automação em alta volume sem gargalos

Instalação

Instalando o EasySpider

1. Baixe a versão mais recente do GitHub Releases
2. Escolha a versão apropriada para sua plataforma:
   • EasySpider_windows_x64.zip para Windows de 64 bits
   • EasySpider_windows_x86.zip para Windows de 32 bits
   • EasySpider_MacOS.dmg para macOS
   • EasySpider_Linux_x64.tar.gz para Linux
3. Extraia o arquivo e execute EasySpider.exe (Windows) ou o executável apropriado

Nota: Certifique-se de que a porta 8084 esteja disponível para comunicação entre processos.

Dependências Python para Integração Personalizada

Se você planeja usar o script auxiliar do CapSolver:

pip install requests

Criando uma Utilidade CapSolver para o EasySpider

Aqui está uma classe de utilidade CapSolver reutilizável projetada para fluxos Python:

Serviço Básico CapSolver

import requests
import time
from typing import Optional
from dataclasses import dataclass

CAPSOLVER_API_KEY = 'SUA_CHAVE_API_CAPSOLVER'

@dataclass
class TaskResult:
    status: str
    solution: Optional[dict] = None
    error_description: Optional[str] = None


class CapSolverService:
    def __init__(self, api_key: str = CAPSOLVER_API_KEY):
        self.api_key = api_key
        self.base_url = 'https://api.capsolver.com'

    def create_task(self, task_data: dict) -> str:
        response = requests.post(
            f'{self.base_url}/createTask',
            json={
                'clientKey': self.api_key,
                'task': task_data
            }
        )
        data = response.json()

        if data.get('errorId', 0) != 0:
            raise Exception(f"Erro do CapSolver: {data.get('errorDescription')}")

        return data['taskId']

    def get_task_result(self, task_id: str, max_attempts: int = 60) -> TaskResult:
        for _ in range(max_attempts):
            time.sleep(2)

            response = requests.post(
                f'{self.base_url}/getTaskResult',
                json={
                    'clientKey': self.api_key,
                    'taskId': task_id
                }
            )
            data = response.json()

            if data.get('status') == 'ready':
                return TaskResult(
                    status='ready',
                    solution=data.get('solution')
                )

            if data.get('status') == 'failed':
                raise Exception(f"Tarefa falhou: {data.get('errorDescription')}")

        raise Exception('Tempo esgotado esperando pela solução do CAPTCHA')

    def solve_recaptcha_v2(self, website_url: str, website_key: str) -> str:
        task_id = self.create_task({
            'type': 'ReCaptchaV2TaskProxyLess',
            'websiteURL': website_url,
            'websiteKey': website_key
        })

        result = self.get_task_result(task_id)
        return result.solution.get('gRecaptchaResponse', '') if result.solution else ''

    def solve_turnstile(
        self,
        website_url: str,
        website_key: str,
        action: Optional[str] = None,
        cdata: Optional[str] = None
    ) -> str:
        task_data = {
            'type': 'AntiTurnstileTaskProxyLess',
            'websiteURL': website_url,
            'websiteKey': website_key
        }

        if action or cdata:
            metadata = {}
            if action:
                metadata['action'] = action
            if cdata:
                metadata['cdata'] = cdata
            task_data['metadata'] = metadata

        task_id = self.create_task(task_data)
        result = self.get_task_result(task_id)
        return result.solution.get('token', '') if result.solution else ''


# Instância global
capsolver = CapSolverService()

Métodos de Integração

O EasySpider oferece várias formas de integrar o CapSolver. Escolha o método que melhor se adequa ao seu caso de uso.

Método 1: Ação Personalizada com Injeção de JavaScript

O EasySpider suporta a execução de JavaScript personalizado dentro do seu fluxo. Este é o método de integração mais direto.

Passo 1: Crie uma nova tarefa no EasySpider e navegue até a página protegida por CAPTCHA

Passo 2: Adicione um nó de "Ação Personalizada" com o seguinte JavaScript:

// Extraia o sitekey do elemento reCAPTCHA
var siteKey = document.querySelector('.g-recaptcha').getAttribute('data-sitekey');
var pageUrl = window.location.href;

// Armazene para uso na próxima etapa
window.captchaSiteKey = siteKey;
window.captchaPageUrl = pageUrl;

// Log para depuração
console.log('Site Key:', siteKey);
console.log('Page URL:', pageUrl);

Passo 3: Use o recurso de chamada de sistema externo do EasySpider para invocar um script Python que resolva o CAPTCHA e retorne o token

Passo 4: Adicione outro nó de "Ação Personalizada" para injetar o token:

// O token será passado do script externo
var token = arguments[0];  // Passado do EasySpider

// Torne o campo de resposta visível e defina o token
document.getElementById('g-recaptcha-response').style.display = 'block';
document.getElementById('g-recaptcha-response').value = token;

// Se houver uma função de retorno, execute-a
if (typeof ___grecaptcha_cfg !== 'undefined') {
    var clients = ___grecaptcha_cfg.clients;
    if (clients) {
        Object.keys(clients).forEach(function(key) {
            var client = clients[key];
            if (client.callback) {
                client.callback(token);
            }
        });
    }
}

Método 1B: Turnstile (Sem Proxy) com EasySpider

Este é um fluxo de Turnstile sem proxy usando os nós visuais do EasySpider. Ele não requer um proxy.

Passo 1: Crie uma nova tarefa e navegue até sua página protegida por Turnstile.

Passo 2: Adicione três nós de Ação Personalizada (modo de código = JavaScript) para capturar os metadados do Turnstile:

// Título do nó: TS_SiteKey
return document.querySelector('.cf-turnstile')?.getAttribute('data-sitekey') || '';

// Título do nó: TS_Action (opcional)
return document.querySelector('.cf-turnstile')?.getAttribute('data-action') || '';

// Título do nó: TS_Cdata (opcional)
return document.querySelector('.cf-turnstile')?.getAttribute('data-cdata') || '';

Passo 3: Adicione um nó de Executar Comando do Sistema para resolver o Turnstile com o CapSolver:

python captcha_solver.py "{{current_url}}" "Field[\"TS_SiteKey\"]" "turnstile" "Field[\"TS_Action\"]" "Field[\"TS_Cdata\"]"

Nomeie esse nó como Token para que você possa referenciá-lo como Field["Token"].

Passo 4: Adicione um nó de Ação Personalizada (JavaScript) para injetar o token:

var token = `Field["Token"]`;
var inputs = document.querySelectorAll('input[name="cf-turnstile-response"], input[name="turnstile-response"]');
inputs.forEach(function(el) {
    el.value = token;
    el.dispatchEvent(new Event('input', { bubbles: true }));
    el.dispatchEvent(new Event('change', { bubbles: true }));
});

Passo 5: Clique no botão de envio do formulário (ou use um envio JS).

Observação: O Turnstile sem proxy funciona em muitos sites, mas alguns deploys validam tokens contra o IP do solver. Se isso acontecer, a resolução com proxy é necessária.

Método 3: Modificando o ExecuteStage do EasySpider

Para usuários avançados, você pode estender diretamente o motor de execução Python do EasySpider. O script easyspider_executestage.py lida com a execução de tarefas e pode ser modificado para incluir a integração com o CapSolver.

Localização: {Diretório do EasySpider}/Code/easyspider_executestage.py

Adicione o serviço CapSolver ao contexto de execução:

# Adicione às importações no topo de easyspider_executestage.py
import requests
import time

# Adicione a classe CapSolver
class CapSolverService:
    # ... (implementação acima)
    pass

# Crie instância global
capsolver = CapSolverService('SUA_CHAVE_API_CAPSOLVER')

# Agora capsolver.solve_recaptcha_v2() está disponível em blocos eval/exec

Em seguida, no seu fluxo do EasySpider, use o recurso "Executar Código Python":

# No bloco de execução Python do EasySpider
site_key = driver.find_element_by_class_name('g-recaptcha').get_attribute('data-sitekey')
token = capsolver.solve_recaptcha_v2(current_url, site_key)
driver.execute_script(f'''
    document.getElementById('g-recaptcha-response').value = `{token}`;
''')

Boas Práticas

1. Tratamento de Erros com Reinícios

import time
from functools import wraps
from typing import Callable, TypeVar, Any

T = TypeVar('T')

def retry(max_retries: int = 3, exponential_backoff: bool = True):
    """Decorador para lógica de reinício com backoff exponencial."""
    def decorator(func: Callable[..., T]) -> Callable[..., T]:
        @wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> T:
            last_exception = None

            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_exception = e

                    if attempt < max_retries - 1:
                        delay = (2 ** attempt) if exponential_backoff else 1
                        print(f'Attempt {attempt + 1} failed, retrying in {delay}s...')
                        time.sleep(delay)

            raise last_exception

        return wrapper
    return decorator


@retry(max_retries=3, exponential_backoff=True)
def solve_with_retry(capsolver, url: str, site_key: str) -> str:
    return capsolver.solve_recaptcha_v2(url, site_key)

2. Gerenciamento de Saldo

def check_balance(api_key: str) -> float:
    response = requests.post(
        'https://api.capsolver.com/getBalance',
        json={'clientKey': api_key}
    )
    data = response.json()
    return data.get('balance', 0)


def main():
    balance = check_balance(CAPSOLVER_API_KEY)

    if balance < 1:
        print('Aviso: Saldo do CapSolver baixo! Por favor, recarregue.')
    else:
        print(f'Saldo atual: ${balance:.2f}')

3. Execução do EasySpider por Linha de Comando

Execute tarefas do EasySpider a partir da linha de comando:

# Execução básica
python easyspider_executestage.py --id [task_id] --read_type local --headless 1

# Com parâmetros completos
python easyspider_executestage.py \
    --ids [0] \
    --server_address http://localhost:8074 \
    --config_folder "./" \
    --headless 1 \
    --read_type local

Fluxo Completo: Tarefa do EasySpider com CapSolver

Aqui está como criar um fluxo completo do EasySpider que inclui a integração com o CapSolver:

Etapa 1: Projete Sua Tarefa no EasySpider

1. Inicie o EasySpider e clique em "Projete Tarefa"
2. Insira a URL de destino (ex.: https://www.google.com/recaptcha/api2/demo)
3. Adicione nós de fluxo:
   • Abrir Página: Navegue até a URL
   • Ação Personalizada: Execute JavaScript para detectar CAPTCHA
   • Chamada de Sistema: Invocar script Python com CapSolver
   • Ação Personalizada: Injetar o token
   • Clicar em Elemento: Submeter o formulário
   • Coletar Dados: Extrair resultados

Etapa 2: Crie o Script Auxiliar do CapSolver

Salve este arquivo como captcha_solver.py no seu diretório EasySpider:

#!/usr/bin/env python3
"""
Script de Ajuda do CapSolver para EasySpider
Uso: python captcha_solver.py <url> <site_key> <tipo_captcha> [ação] [cdata]
"""

import sys
import requests
import time

CHAVE_API_CAPSOLVER = 'SUA_CHAVE_API_CAPSOLVER'

def resolver_captcha(url, site_key, tipo_captcha='recaptcha_v2', acao=None, cdata=None):
    """Resolver CAPTCHA e retornar token."""

    if tipo_captcha == 'recaptcha_v2':
        tipo_tarefa = 'ReCaptchaV2TaskProxyLess'
    elif tipo_captcha == 'turnstile':
        tipo_tarefa = 'AntiTurnstileTaskProxyLess'
    else:
        raise ValueError(f'Tipo de CAPTCHA desconhecido: {tipo_captcha}')

    # Criar tarefa
    tarefa = {
        'type': tipo_tarefa,
        'websiteURL': url,
        'websiteKey': site_key
    }
    if tipo_captcha == 'turnstile' and (acao or cdata):
        metadata = {}
        if acao:
            metadata['acao'] = acao
        if cdata:
            metadata['cdata'] = cdata
        tarefa['metadata'] = metadata

    response = requests.post(
        'https://api.capsolver.com/createTask',
        json={
            'clientKey': CHAVE_API_CAPSOLVER,
            'task': tarefa
        }
    )
    dados = response.json()

    if dados.get('errorId', 0) != 0:
        raise Exception(f"Erro: {dados.get('errorDescription')}")

    id_tarefa = dados['taskId']

    # Verificar resultado
    for _ in range(60):
        time.sleep(2)

        response = requests.post(
            'https://api.capsolver.com/getTaskResult',
            json={
                'clientKey': CHAVE_API_CAPSOLVER,
                'taskId': id_tarefa
            }
        )
        dados = response.json()

        if dados.get('status') == 'ready':
            solucao = dados.get('solution', {})
            return solucao.get('gRecaptchaResponse') or solucao.get('token')

        if dados.get('status') == 'failed':
            raise Exception(f"Falha: {dados.get('errorDescription')}")

    raise Exception('Tempo esgotado')


if __name__ == '__main__':
    if len(sys.argv) < 3:
        print('Uso: python captcha_solver.py <url> <site_key> [tipo_captcha] [acao] [cdata]')
        sys.exit(1)

    url = sys.argv[1]
    site_key = sys.argv[2]
    tipo_captcha = sys.argv[3] if len(sys.argv) > 3 else 'recaptcha_v2'
    acao = sys.argv[4] if len(sys.argv) > 4 else None
    cdata = sys.argv[5] if len(sys.argv) > 5 else None

    try:
        token = resolver_captcha(url, site_key, tipo_captcha, acao, cdata)
        print(token)  # Saída do token para o EasySpider capturar
    except Exception as e:
        print(f'ERRO: {e}', file=sys.stderr)
        sys.exit(1)

Etapa 3: Configurar o EasySpider para Usar o Script

No seu fluxo de trabalho do EasySpider, adicione um nó "Executar Comando do Sistema":

python captcha_solver.py "{{current_url}}" "{{site_key}}" "recaptcha_v2"

Para Turnstile (sem proxy):

python captcha_solver.py "{{current_url}}" "{{site_key}}" "turnstile" "{{acao}}" "{{cdata}}"

A saída (token) pode ser capturada e usada em etapas subsequentes de injeção de JavaScript.

Conclusão

A integração do CapSolver com o EasySpider cria uma combinação poderosa para automação visual de sites. A interface de fluxo gráfico do EasySpider torna o design de tarefas acessível a todos, enquanto o CapSolver lida com os desafios CAPTCHA que, de outra forma, bloqueariam sua automação.

Vantagens principais desta integração:

• Visual + Poderoso: Projete tarefas visualmente enquanto lida com CAPTCHAs complexos
• Múltiplos Métodos de Integração: Injeção de JavaScript, scripts Python ou modificação direta
• Todos os Tipos de CAPTCHA: reCAPTCHA v2, v3, Cloudflare Turnstile, desafio e mais
• Pronto para Produção: Gerenciamento de erros, tentativas de novo e balanço incluído
• Multiplataforma: Funciona em Windows, macOS e Linux

Seja para construir pipelines de extração de dados, sistemas de monitoramento ou frameworks de teste automatizado, a combinação EasySpider + CapSolver fornece a experiência de design visual e a capacidade de resolver CAPTCHAs necessárias para automação web moderna.

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

Perguntas Frequentes

O que é EasySpider?

EasySpider é uma ferramenta de raspagem de web e automação de navegador gratuita e de código aberto. Ele permite que os usuários projetem tarefas de automação por meio de uma interface gráfica de fluxo sem precisar escrever código, enquanto também suporta código JavaScript, Python e declarações Selenium para casos avançados.

Como o CapSolver se integra ao EasySpider?

O CapSolver se integra ao EasySpider por meio de múltiplos métodos: injeção de JavaScript personalizada dentro do fluxo do EasySpider, scripts Python externos chamados por comandos do sistema ou modificação direta do motor de execução Python do EasySpider. Todos os métodos usam a API do CapSolver para resolver CAPTCHAs e injetar tokens na página.

O EasySpider resolve CAPTCHAs por conta própria?

O EasySpider tem suporte integrado para alguns esquemas de reconhecimento de CAPTCHA e capacidades de OCR. No entanto, a integração com o CapSolver fornece taxas de sucesso mais altas, tempos de resolução mais rápidos e cobertura mais ampla de tipos de CAPTCHA para fluxos de automação de produção.

Quais tipos de CAPTCHAs o CapSolver pode resolver?

O CapSolver suporta uma ampla gama de tipos de CAPTCHA, incluindo reCAPTCHA v2, reCAPTCHA v3, Cloudflare Turnstile, AWS WAF, GeeTest v3/v4 e muitos mais.

Quanto custa o CapSolver?

O CapSolver oferece preços competitivos com base no tipo e volume de CAPTCHAs resolvidos. Visite capsolver.com para detalhes de preços atuais. Use o código EASYSPIDER para obter um bônus de 5% na sua primeira recarga.

O EasySpider é gratuito para uso?

Sim, o EasySpider é totalmente gratuito e de código aberto sob a licença AGPL-3.0. O software permite uso comercial gratuito e modificação. As implantações de serviços de rede devem fornecer acesso ao código-fonte aos usuários.

Como encontrar a chave do CAPTCHA do site?

A chave do site geralmente é encontrada no código-fonte da página:

• reCAPTCHA: atributo data-sitekey no elemento .g-recaptcha
• Turnstile: atributo data-sitekey no elemento .cf-turnstile

Posso executar tarefas do EasySpider pela linha de comando?

Sim, o EasySpider suporta execução via linha de comando através de easyspider_executestage.py. Isso permite integração com outros sistemas, execução de tarefas agendadas e automação em modo sem interface.

Quais plataformas o EasySpider suporta?

O EasySpider está disponível para Windows (x64/x86), macOS e Linux. Baixe a versão apropriada na página de lançamentos do GitHub.

Posso usar o EasySpider com proxies?

Sim, o EasySpider suporta configuração de IP de proxy e troca de túneis. Você pode configurar proxies nas configurações da tarefa ou através das opções de inicialização do navegador do EasySpider.