Como Resolver CAPTCHA no Navegador usando a API CapSolver

O uso do navegador é uma poderosa biblioteca Python de código aberto que permite que agentes de IA controlem navegadores da web para automatizar tarefas como raspagem de dados, preenchimento de formulários e atividades online repetitivas. Ao aproveitar o Playwright para automação do navegador e integrar-se a modelos de linguagem grandes (LLMs) como os modelos GPT da OpenAI, o uso do navegador permite que os usuários emitam comandos em linguagem natural, tornando-o acessível mesmo para aqueles sem habilidades de codificação extensas. No entanto, um desafio comum na automação da web é encontrar CAPTCHAs, que são projetados para bloquear scripts automatizados e podem interromper os fluxos de trabalho do uso do navegador.

O CapSolver é um serviço alimentado por IA que se especializa em resolver vários tipos de CAPTCHAs, incluindo reCAPTCHA e Cloudflare Turnstile. Ao integrar o CapSolver com o uso do navegador, você pode garantir que suas tarefas de automação prossigam sem problemas, sem exigir intervenção manual para resolver CAPTCHAs.

Este artigo fornece um guia passo a passo sobre como integrar o CapSolver com o uso do navegador para lidar com CAPTCHAs de forma eficaz. Abordaremos a configuração necessária, forneceremos um exemplo de código completo e compartilharemos as melhores práticas para ajudá-lo a começar.

Visão geral e casos de uso do navegador

O Browser-use é uma biblioteca Python que simplifica a automação da web, permitindo que agentes de IA interajam com sites por meio de instruções em linguagem natural. Ele usa o Playwright nos bastidores para controlar navegadores como Chromium, Firefox e WebKit, e integra-se a LLMs para interpretar e executar comandos do usuário. Isso torna o uso do navegador ideal para automatizar tarefas complexas sem escrever código extenso.

Casos de uso

O uso do navegador suporta uma variedade de tarefas de automação, incluindo:

• Raspagem de dados: extração de dados de sites para pesquisa de mercado, monitoramento de preços ou agregação de conteúdo.
• Preenchimento de formulários: automatização do processo de preenchimento de formulários online com dados de várias fontes, como candidaturas a empregos ou registros de contas.
• Automação de tarefas: execução de tarefas repetitivas, como entrar em contas, navegar em sites ou clicar em botões.

Essas tarefas geralmente envolvem interagir com sites que implantam CAPTCHAs para evitar acesso automatizado, tornando uma solução confiável de resolução de CAPTCHA essencial para automação ininterrupta.

Por que a resolução de CAPTCHA é necessária

Os sites costumam implantar defesas anti-bot como CAPTCHAs para bloquear acesso automatizado, spam e atividades maliciosas. Esses CAPTCHAs — projetados para diferenciar humanos de bots com desafios como clicar em caixas de seleção ou resolver quebra-cabeças de imagem — representam um obstáculo significativo para a raspagem da web. Ao automatizar tarefas com o uso do navegador, encontrar um CAPTCHA pode interromper o processo, impedindo que a ferramenta raspe os dados desejados sem intervenção manual.

Os tipos comuns de CAPTCHA incluem:

Para raspagem da web, este é um problema crítico: os CAPTCHAs são especificamente destinados a frustrar o tipo de automação que o uso do navegador usa para extrair dados de sites. Sem uma maneira de contornar essas barreiras, os esforços de raspagem são interrompidos, tornando a automação ineficaz. Felizmente, a integração da API do CapSolver com o uso do navegador fornece uma solução poderosa. O CapSolver resolve automaticamente esses CAPTCHAs, permitindo que o uso do navegador passe pelas defesas anti-bot e raspe dados com sucesso sem interrupção. Seja lidando com reCAPTCHA v2 ou Cloudflare Turnstile, o CapSolver garante que o uso do navegador possa lidar com uma ampla gama de desafios de CAPTCHA, tornando-se uma ferramenta essencial para extração de dados perfeita e eficiente de sites protegidos.

Essa integração muda o jogo para quem deseja raspar dados de sites que usam CAPTCHAs, pois elimina a necessidade de entrada manual e mantém o processo de raspagem da web funcionando sem problemas.

Como usar o CapSolver para lidar com CAPTCHAs

O CapSolver oferece uma API que pode resolver vários CAPTCHAs usando algoritmos de IA avançados. Para integrar o CapSolver com o uso do navegador, você pode definir uma ação personalizada usando o decorador @controller.action. Essa ação detectará CAPTCHAs em uma página da web, extrairá informações necessárias (por exemplo, a chave do site para reCAPTCHA), chamará a API do CapSolver para obter uma solução e injetará a solução na página.

Passos para integrar o CapSolver com o uso do navegador

1. Cadastre-se no CapSolver: crie uma conta no CapSolver, adicione fundos e obtenha sua chave de API.
2. Configure o uso do navegador: instale o uso do navegador e suas dependências e configure seu ambiente com chaves de API para um provedor de LLM (por exemplo, OpenAI).
3. Instale dependências: use Python e instale os pacotes necessários: browser-use, playwright e requests.
4. Defina uma ação personalizada: crie uma ação personalizada em seu script de uso do navegador para lidar com CAPTCHAs usando a API do CapSolver.
5. Execute o agente: instrua o agente de IA a chamar a ação personalizada quando um CAPTCHA for encontrado durante a execução da tarefa.

Fragmento de código-chave

Abaixo está um exemplo de uma ação personalizada para resolver um reCAPTCHA v2 usando a API do CapSolver:

import requests
import time
from browser_use import Controller, ActionResult
from playwright.async_api import Page

CAPSOLVER_API_KEY = 'YOUR_CAPSOLVER_API_KEY'

@controller.action('Solve CAPTCHA', domains=['*'])
async def solve_captcha(page: Page) -> ActionResult:
    if await page.query_selector('.g-recaptcha'):
        site_key = await page.evaluate("document.querySelector('.g-recaptcha').getAttribute('data-sitekey')")
        page_url = page.url

        # Create task with CapSolver
        response = requests.post('https://api.capsolver.com/createTask', json={
            'clientKey': CAPSOLVER_API_KEY,
            'task': {
                'type': 'ReCaptchaV2TaskProxyLess',
                'websiteURL': page_url,
                'websiteKey': site_key,
            }
        })
        task_id = response.json().get('taskId')
        if not task_id:
            return ActionResult(success=False, message='Failed to create CapSolver task')

        # Poll for solution
        while True:
            time.sleep(5)
            result_response = requests.post('https://api.capsolver.com/getTaskResult', json={
                'clientKey': CAPSOLVER_API_KEY,
                'taskId': task_id
            })
            result = result_response.json()
            if result.get('status') == 'ready':
                solution = result.get('solution', {}).get('gRecaptchaResponse')
                if solution:
                    await page.evaluate(f"document.getElementById('g-recaptcha-response').innerHTML = '{solution}';")
                    return ActionResult(success=True, message='CAPTCHA solved')
                else:
                    return ActionResult(success=False, message='No solution found')
            elif result.get('status') == 'failed':
                return ActionResult(success=False, message='CapSolver failed to solve CAPTCHA')
    return ActionResult(success=False, message='No CAPTCHA found')

Este trecho define uma ação personalizada que verifica a existência de um elemento reCAPTCHA v2, extrai a chave do site, cria uma tarefa com o CapSolver, pesquisa a solução e injeta o token na página.

Exemplo de código completo + Explicação passo a passo

Abaixo está um exemplo de código completo que demonstra como integrar o CapSolver com o uso do navegador para resolver CAPTCHAs.

Pré-requisitos

Certifique-se de ter os pacotes necessários instalados:

pip install browser-use playwright requests
playwright install

Configure seu ambiente com as chaves de API necessárias. Crie um arquivo .env com suas chaves de API OpenAI e CapSolver:

OPENAI_API_KEY=your_openai_api_key
CAPSOLVER_API_KEY=your_capsolver_api_key

Exemplo de código completo

Crie um script Python com o seguinte conteúdo:

import os
import asyncio
import requests
from dotenv import load_dotenv
from browser_use import Agent, Controller, ActionResult
from browser_use.browser import BrowserSession
from browser_use.llm import ChatOpenAI
from playwright.async_api import Page

# Load environment variables from .env file
load_dotenv()

CAPSOLVER_API_KEY = os.getenv('CAPSOLVER_API_KEY')

controller = Controller()

@controller.action('Solve CAPTCHA', domains=['*'])
async def solve_captcha(page) -> ActionResult:
    if await page.query_selector('.g-recaptcha'):
        site_key = await page.evaluate("document.querySelector('.g-recaptcha').getAttribute('data-sitekey')")
        page_url = page.url

        response = requests.post('https://api.capsolver.com/createTask', json={
            'clientKey': CAPSOLVER_API_KEY,
            'task': {
                'type': 'ReCaptchaV2TaskProxyLess',
                'websiteURL': page_url,
                'websiteKey': site_key,
            }
        })

        task_id = response.json().get('taskId')
        print(task_id)
        if not task_id:
            return ActionResult(success=False, message='Failed to create CapSolver task')

        while True:
            await asyncio.sleep(5)
            result_response = requests.post('https://api.capsolver.com/getTaskResult', json={
                'clientKey': CAPSOLVER_API_KEY,
                'taskId': task_id
            })
            result = result_response.json()
            print(f"CAPTCHA result status: {result.get('status')}")
            if result.get('status') == 'ready':
                solution = result.get('solution', {}).get('gRecaptchaResponse')
                print(f"CAPTCHA solution: {solution}")
                if solution:
                    print("Submitting CAPTCHA solution...")
                    # Try both possible input fields for the CAPTCHA token
                    await page.evaluate(f"""
                        // Try the standard g-recaptcha-response field
                        var gRecaptchaResponse = document.getElementById('g-recaptcha-response');
                        if (gRecaptchaResponse) {{
                            gRecaptchaResponse.innerHTML = '{solution}';
                            var event = new Event('input', {{ bubbles: true }});
                            gRecaptchaResponse.dispatchEvent(event);
                        }}
                        
                        // Also try the recaptcha-token field
                        var recaptchaToken = document.getElementById('recaptcha-token');
                        if (recaptchaToken) {{
                            recaptchaToken.value = '{solution}';
                            var event = new Event('input', {{ bubbles: true }});
                            recaptchaToken.dispatchEvent(event);
                        }}
                    """)
                    
                    # Wait a moment for the token to be processed
                    await asyncio.sleep(2)
                    print("Token injected successfully! CAPTCHA solved.")
                    
                    # Method 2: Click submit button directly using the correct selector
                    print("Now clicking submit button...")
                    try:
                        # Use the specific button selector you provided
                        submit_button = await page.query_selector("body > main > form > fieldset > button")
                        if submit_button:
                            await submit_button.click()
                            print("✅ Submit button clicked successfully!")
                        else:
                            print("❌ Submit button not found!")
                            return ActionResult(success=False, message='Submit button not found')
                    except Exception as e:
                        print(f"❌ Error clicking submit button: {e}")
                        return ActionResult(success=False, message=f'Error clicking submit: {e}')
                    
                    print("CAPTCHA solved and form submitted successfully!")
                    return ActionResult(success=True, message='CAPTCHA solved and form submitted')
                   
                else:
                    return ActionResult(success=False, message='No solution found')
            elif result.get('status') == 'failed':
                return ActionResult(success=False, message='CapSolver failed to solve CAPTCHA')
    return ActionResult(success=False, message='No CAPTCHA found')

llm = ChatOpenAI(model="gpt-4o-mini")

async def main():
    try:
        print("🚀 Starting browser-use CAPTCHA solver agent...")
        
        # Simple task instruction for CAPTCHA solving and form submission
        task = """Navigate to https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php and solve the CAPTCHA, then submit the form.

STEP 1: Navigate to the reCAPTCHA demo page: https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php

STEP 2: Wait for the page to fully load. You should see a form with input fields and a reCAPTCHA checkbox.

STEP 3: Look for a reCAPTCHA element (usually a checkbox that says "I'm not a robot" or similar).

STEP 4: Use the "solve_captcha" action to automatically solve the CAPTCHA and submit the form.

STEP 5: Report the final result.

Note: The solve_captcha action will handle both solving the CAPTCHA and submitting the form automatically."""
        
        # Create browser session first
        browser_session = BrowserSession()
        
        # Create agent with the browser session
        agent = Agent(
            task=task, 
            llm=llm, 
            controller=controller,
            browser_session=browser_session
        )
        
        print("📱 Running CAPTCHA solver agent...")
        result = await agent.run()
        print(f"✅ Agent completed: {result}")
        
        # Keep browser open to see results
        input('Press Enter to close the browser...')
        await browser_session.close()
        
    except Exception as e:
        print(f"❌ Error: {e}")

if __name__ == "__main__":
    asyncio.run(main())

Explicação passo a passo

| 1. Instale as Dependências | Instale browser-use, playwright, e requests usando pip install browser-use playwright requests. Execute playwright install para instalar os navegadores necessários. |
| 2. Configure o Ambiente | Crie um arquivo .env com suas chaves de API OpenAI e CapSolver para armazenar credenciais de forma segura. |
| 3. Defina a Ação Personalizada | Use o decorador @controller.action para definir solve_captcha, que verifica a existência de um elemento reCAPTCHA v2, extrai a chave do site, chama a API do CapSolver e injeta a solução na página. |
| 4. Inicialize o Controlador e o Agente | Crie uma instância Controller, defina a ação personalizada, inicialize o LLM (por exemplo, ChatOpenAI com GPT-4o-mini) e crie o agente BrowserUse com o controlador. |
| 5. Execute o Agente | Forneça uma tarefa que inclua instruções para resolver CAPTCHAs usando a ação personalizada se encontrados. O agente navega até a URL especificada, detecta o CAPTCHA, chama a ação personalizada e envia o formulário. |
| 6. Tratamento de Erros | A ação personalizada inclui tratamento de erros para casos em que a tarefa CapSolver falha ou nenhuma solução é encontrada, retornando objetos ActionResult apropriados. |
| 7. Limpeza | O agente gerencia automaticamente os recursos do navegador, fechando o navegador quando a tarefa estiver concluída. |

Este exemplo foca no reCAPTCHA v2, mas você pode adaptá-lo para outros tipos de CAPTCHA modificando o tipo de tarefa (por exemplo, AntiTurnstileTaskProxyLess para Turnstile).

Demonstração

Esta seção descreve como a integração funciona usando uma tarefa de exemplo para navegar até uma página de demonstração com uma caixa de seleção reCAPTCHA v2 e enviar o formulário.

1. Configuração da Tarefa: A tarefa instrui o agente de IA a visitar https://recaptcha-demo.appspot.com/recaptcha-v2-checkbox.php, enviar o formulário e resolver quaisquer CAPTCHAs usando a ação solve_captcha.
2. Execução do Agente: O agente Browser-use inicia um navegador controlado pelo Playwright e navega até a URL especificada.
3. Detecção de CAPTCHA: O agente verifica a existência de um CAPTCHA procurando o elemento .g-recaptcha. Se encontrado, ele aciona a ação solve_captcha.
4. Execução da Ação Personalizada: A ação solve_captcha extrai a chave do site e a URL da página, cria uma tarefa com a API do CapSolver e pesquisa a solução.
5. Injeção da Solução: Assim que a solução for recebida, a ação injeta o token no campo g-recaptcha-response.
6. Envio do Formulário: O agente envia o formulário clicando no botão de envio, completando a tarefa.
7. Conclusão da Tarefa: O agente retorna o resultado, indicando o envio bem-sucedido do formulário.

Visualmente, você veria o navegador navegar até a página de demonstração, a caixa de seleção reCAPTCHA sendo marcada automaticamente após a injeção da solução e o formulário sendo enviado com sucesso.

Seção de Perguntas Frequentes

Conclusão

A integração do CapSolver com o Browser-use fornece uma solução robusta para lidar com CAPTCHAs em tarefas de automação da web. Ao definir uma ação personalizada para resolver CAPTCHAs, você pode garantir que seus agentes de IA naveguem em sites sem problemas, mesmo quando confrontados com medidas anti-bot. Essa combinação aproveita a facilidade de uso do Browser-use e os poderosos recursos de resolução de CAPTCHA do CapSolver para criar fluxos de trabalho de automação eficientes.

Para começar, inscreva-se no CapSolver e explore o Browser-use. Siga as instruções de configuração e implemente o exemplo de código fornecido. Para mais detalhes, visite a documentação do CapSolver e a documentação do Browser-use. Experimente essa integração em seu próximo projeto de automação e experimente a facilidade de resolver CAPTCHAs automaticamente!

Bônus para usuários do Browser-use: Use o código promocional BROWSERUSE ao recarregar sua conta CapSolver e receba um crédito bônus exclusivo de 6% — sem limites, sem expiração.

Navegadores e Ferramentas Suportados

• Browser-use: Usa Playwright, suportando navegadores Chromium, Firefox e WebKit.
• CapSolver: Compatível com qualquer cliente com capacidade HTTP, incluindo extensões de navegador para Chrome e Firefox.

Saiba Mais e Explore Outros Tipos de Frameworks

• Browser-use GitHub
• Site Oficial do CapSolver
• Documentação do Playwright
• Documentação do CapSolver
• Documentação do Browser-use