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