Como resolver CAPTCHAs em Python usando Botasaurus e CapSolver (Guia Completo)

Adélia Cruz

Neural Network Developer

15-Dec-2025

TLDR: Este guia demonstra como combinar o Botasaurus, um framework de raspagem de web em Python com recursos integrados de anti-deteção, e o CapSolver, uma API de resolução de CAPTCHA, para burlar automaticamente reCAPTCHA v2, reCAPTCHA v3 e Cloudflare Turnstile durante a raspagem em larga escala. O processo central envolve configurar o ambiente, usar a extensão do navegador CapSolver para identificar os parâmetros do captcha, chamar a API CapSolver via uma função auxiliar em Python para obter um token de solução e, por fim, usar o Botasaurus para injetar o token na página para submissão de formulário.

Como resolver CAPTCHAs em Python usando Botasaurus e CapSolver (Guia completo)

A raspagem de web em larga escala frequentemente encontra CAPTCHAs que bloqueiam o acesso automatizado. Este guia demonstra como combinar o Botasaurus, um framework de raspagem de web poderoso, com o CapSolver para resolver automaticamente CAPTCHAs reCAPTCHA v2, reCAPTCHA v3 e Cloudflare Turnstile.

O que é Botasaurus?

Botasaurus é um framework de raspagem de web em Python que simplifica a automação do navegador com recursos de anti-deteção integrados. Ele fornece uma API baseada em decoradores limpa para tarefas de navegador.

Funcionalidades principais:

Anti-deteção: Recursos de stealth integrados para evitar a detecção de bots
API simples: Abordagem baseada em decoradores com @browser
Execução de JavaScript: Execute código JS personalizado no contexto do navegador
Seleção de elementos: Manipulação fácil do DOM com seletores CSS

Instalação:

bash Copy

pip install botasaurus

Uso básico:

python Copy

from botasaurus.browser import browser, Driver

@browser()
def scrape_page(driver: Driver, data):
    driver.get("https://example.com")
    title = driver.get_text("h1")
    return {"title": title}

# Execute o raspador
result = scrape_page()

O que é CapSolver?

CapSolver é um serviço de resolução de CAPTCHA que fornece uma API para resolver vários tipos de CAPTCHA, incluindo reCAPTCHA e Cloudflare Turnstile.

Tipos de CAPTCHA suportados:

reCAPTCHA v2 (checkbox e invisível)
reCAPTCHA v3 (baseado em pontuação)
reCAPTCHA Enterprise
Cloudflare Turnstile
E muito mais

Obtendo sua chave de API:

Crie uma conta no Painel do CapSolver
Adicione fundos à sua conta
Copie sua chave de API (começa com CAP-)

Configuração do Projeto

Instalar Dependências

bash Copy

pip install botasaurus capsolver requests python-dotenv

Configurar Ambiente

Crie um arquivo .env na raiz do seu projeto:

env Copy

CAPSOLVER_API_KEY=CAP-SUA_CHAVE_DE_API_AQUI

Módulo de Configuração

Crie um carregador de configuração compartilhado:

python Copy

# shared/config.py
import os
from pathlib import Path
from dotenv import load_dotenv

# Carregue o arquivo .env da raiz do projeto
ROOT_DIR = Path(__file__).parent.parent
load_dotenv(ROOT_DIR / ".env")

class Config:
    """Classe de configuração para integração com CapSolver."""

    # Chave de API do CapSolver
    CAPSOLVER_API_KEY: str = os.getenv("CAPSOLVER_API_KEY", "")

    # Endpoints da API do CapSolver
    CAPSOLVER_API_URL = "https://api.capsolver.com"
    CREATE_TASK_ENDPOINT = f"{CAPSOLVER_API_URL}/createTask"
    GET_RESULT_ENDPOINT = f"{CAPSOLVER_API_URL}/getTaskResult"

    @classmethod
    def validate(cls) -> bool:
        """Verifique se a configuração é válida."""
        if not cls.CAPSOLVER_API_KEY:
            print("Erro: CAPSOLVER_API_KEY não definida!")
            return False
        return True

Identificando os parâmetros do CAPTCHA com a extensão CapSolver

Antes de integrar com a API, você precisa identificar os parâmetros corretos para o captcha alvo. A extensão CapSolver fornece uma maneira fácil de detectar todos os parâmetros necessários automaticamente.

Instalação

Instale a extensão CapSolver da Chrome Web Store.

Usando o detector de CAPTCHA

Pressione F12 para abrir as ferramentas do desenvolvedor
Navegue até a aba Capsolver Captcha Detector
Mantenha o painel do detector aberto enquanto visita seu site alvo
Dispare o CAPTCHA na página

Importante: Não feche o painel do CapSolver antes de disparar o CAPTCHA, pois fechá-lo apaga as informações anteriormente detectadas.

Parâmetros detectados

A extensão identifica automaticamente todos os parâmetros necessários do reCAPTCHA:

URL do site
Chave do site
pageAction (para v3)
isInvisible
isEnterprise
Api Domain

O detector fornece uma saída JSON formatada pronta para integração com a API, facilitando a cópia dos parâmetros exatos necessários para suas tarefas de resolução.

Para mais detalhes, consulte o guia completo sobre identificação de parâmetros de CAPTCHA.

Resolvendo reCAPTCHA v2 com a API CapSolver

reCAPTCHA v2 é o clássico CAPTCHA de checkbox "Não sou um robô". Ele pode apresentar desafios de seleção de imagem aos usuários.

Encontrando a Chave do Site

Você pode usar o detector da extensão CapSolver (descrito acima) ou encontrar a chave do site manualmente:

Procure no HTML da página:

html Copy

<div class="g-recaptcha" data-sitekey="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"></div>

Ou no JavaScript:

javascript Copy

grecaptcha.render('container', {'sitekey': '6Le-xxxxx...'});

Função auxiliar

python Copy

# utils/capsolver_helper.py
import time
import requests
from shared.config import Config

def solve_recaptcha_v2(
    website_url: str,
    website_key: str,
    is_invisible: bool = False,
    timeout: int = 120
) -> dict:
    """
    Resolva reCAPTCHA v2 usando a API CapSolver.

    Args:
        website_url: A URL da página com o CAPTCHA
        website_key: A chave do site reCAPTCHA
        is_invisible: Se é reCAPTCHA v2 invisível
        timeout: Tempo máximo para esperar a solução (segundos)

    Returns:
        dicionário com o token 'gRecaptchaResponse'
    """

    if not Config.validate():
        raise Exception("Configuração inválida - verifique sua chave de API")

    # Construa o payload da tarefa
    task = {
        "type": "ReCaptchaV2TaskProxyLess",
        "websiteURL": website_url,
        "websiteKey": website_key,
    }

    if is_invisible:
        task["isInvisible"] = True

    payload = {
        "clientKey": Config.CAPSOLVER_API_KEY,
        "task": task
    }

    # Crie a tarefa
    response = requests.post(Config.CREATE_TASK_ENDPOINT, json=payload)
    result = response.json()

    if result.get("errorId") and result.get("errorId") != 0:
        raise Exception(f"Falha ao criar a tarefa: {result.get('errorDescription')}")

    task_id = result.get("taskId")

    # Verifique resultados
    start_time = time.time()
    while time.time() - start_time < timeout:
        time.sleep(2)

        result_payload = {
            "clientKey": Config.CAPSOLVER_API_KEY,
            "taskId": task_id
        }

        response = requests.post(Config.GET_RESULT_ENDPOINT, json=result_payload)
        result = response.json()

        if result.get("status") == "ready":
            return result.get("solution", {})

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

    raise Exception(f"Tempo esgotado após {timeout} segundos")

Exemplo completo de reCAPTCHA v2

python Copy

from botasaurus.browser import browser, Driver
from shared.config import Config
from utils.capsolver_helper import solve_recaptcha_v2

DEMO_URL = "https://www.google.com/recaptcha/api2/demo"
DEMO_SITEKEY = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"

@browser(headless=False)
def solve_recaptcha_v2_with_api(driver: Driver, data: dict):
    """Resolva reCAPTCHA v2 usando a API CapSolver e injete o token."""

    url = data.get("url", DEMO_URL)
    site_key = data.get("site_key", DEMO_SITEKEY)

    # Etapa 1: Carregar a página
    driver.get(url)
    driver.sleep(2)

    # Etapa 2: Extrair a chave do site da página (opcional)
    extracted_key = driver.run_js("""
        const recaptchaDiv = document.querySelector('.g-recaptcha');
        return recaptchaDiv ? recaptchaDiv.getAttribute('data-sitekey') : null;
    """)

    if extracted_key:
        site_key = extracted_key

    # Etapa 3: Resolver o CAPTCHA via API CapSolver
    solution = solve_recaptcha_v2(
        website_url=url,
        website_key=site_key
    )

    token = solution.get("gRecaptchaResponse")

    # Etapa 4: Injetar o token na página
    driver.run_js(f"""
        // Defina o valor do campo de texto oculto
        const responseField = document.querySelector('[name="g-recaptcha-response"]');
        if (responseField) {{
            responseField.value = "{token}";
        }}

        // Dispare o callback se disponível
        if (typeof ___grecaptcha_cfg !== 'undefined') {{
            try {{
                const clients = ___grecaptcha_cfg.clients;
                for (const key in clients) {{
                    const client = clients[key];
                    if (client && client.callback) {{
                        client.callback("{token}");
                    }}
                }}
            }} catch (e) {{}}
        }}
    """)

    # Etapa 5: Submeter o formulário
    submit_button = driver.select('input[type="submit"]')
    if submit_button:
        submit_button.click()
        driver.sleep(2)

    return {"success": True, "token_length": len(token)}

# Execute o demo
result = solve_recaptcha_v2_with_api(data={"url": DEMO_URL, "site_key": DEMO_SITEKEY})

Resolvendo reCAPTCHA v3 com a API CapSolver

reCAPTCHA v3 é invisível e funciona analisando o comportamento do usuário para gerar uma pontuação de 0,0 a 1,0.

Diferença principal em relação ao v2: reCAPTCHA v3 requer um parâmetro pageAction.

Encontrando o pageAction

A maneira mais fácil de encontrar o pageAction é usando o detector de CAPTCHA do CapSolver. Alternativamente, procure no JavaScript da página:

javascript Copy

grecaptcha.execute('siteKey', {action: 'login'})
// 'login' é seu pageAction

Função auxiliar

python Copy

def solve_recaptcha_v3(
    website_url: str,
    website_key: str,
    page_action: str,
    timeout: int = 120
) -> dict:
    """
    Resolva reCAPTCHA v3 usando a API CapSolver.

    Args:
        website_url: A URL da página com o CAPTCHA
        website_key: A chave do site reCAPTCHA
        page_action: O parâmetro de ação (OBRIGATÓRIO para v3)
        timeout: Tempo máximo para esperar a solução (segundos)

    Returns:
        dicionário com o token 'gRecaptchaResponse'
    """

    if not Config.validate():
        raise Exception("Configuração inválida - verifique sua chave de API")

    if not page_action:
        raise Exception("pageAction é OBRIGATÓRIO para reCAPTCHA v3")

    # Construa o payload da tarefa
    task = {
        "type": "ReCaptchaV3TaskProxyLess",
        "websiteURL": website_url,
        "websiteKey": website_key,
        "pageAction": page_action,  # OBRIGATÓRIO para v3
    }

    payload = {
        "clientKey": Config.CAPSOLVER_API_KEY,
        "task": task
    }

    # Crie a tarefa
    response = requests.post(Config.CREATE_TASK_ENDPOINT, json=payload)
    result = response.json()

    if result.get("errorId") and result.get("errorId") != 0:
        raise Exception(f"Falha ao criar a tarefa: {result.get('errorDescription')}")

    task_id = result.get("taskId")

    # Verifique resultados
    start_time = time.time()
    while time.time() - start_time < timeout:
        time.sleep(2)

        result_payload = {
            "clientKey": Config.CAPSOLVER_API_KEY,
            "taskId": task_id
        }

        response = requests.post(Config.GET_RESULT_ENDPOINT, json=result_payload)
        result = response.json()

        if result.get("status") == "ready":
            return result.get("solution", {})

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

    raise Exception(f"Tempo esgotado após {timeout} segundos")

Exemplo completo de reCAPTCHA v3

python Copy

from botasaurus.browser import browser, Driver
from shared.config import Config
from utils.capsolver_helper import solve_recaptcha_v3

DEMO_URL = "https://recaptcha-demo.appspot.com/recaptcha-v3-request-scores.php"
DEMO_SITEKEY = "6LdyC2cUAAAAACGuDKpXeDorzUDWXmdqeg-xy696"
PAGE_ACTION = "examples/v3scores"

@browser(headless=False)
def solve_recaptcha_v3_with_api(driver: Driver, data: dict):
    """Resolva reCAPTCHA v3 usando a API CapSolver e injete o token."""

    url = data.get("url", DEMO_URL)
    site_key = data.get("site_key", DEMO_SITEKEY)
    page_action = data.get("page_action", PAGE_ACTION)

    # Etapa 1: Carregar a página
    driver.get(url)
    driver.sleep(2)

    # Etapa 2: Resolver o CAPTCHA via API CapSolver
    solution = solve_recaptcha_v3(
        website_url=url,
        website_key=site_key,
        page_action=page_action
    )

    token = solution.get("gRecaptchaResponse")

    # Etapa 3: Injetar o token na página
    driver.run_js(f"""
        const token = "{token}";

        // Defina o campo oculto se existir
        const responseField = document.querySelector('[name="g-recaptcha-response"]');
        if (responseField) {{
            responseField.value = token;
        }}

        // Crie o campo oculto se o formulário existir, mas o campo não
        const forms = document.querySelectorAll('form');
        forms.forEach(form => {{
            let field = form.querySelector('[name="g-recaptcha-response"]');
            if (!field) {{
                field = document.createElement('input');
                field.type = 'hidden';
                field.name = 'g-recaptcha-response';
                form.appendChild(field);
            }}
            field.value = token;
        }});
    """)

    # Etapa 4: Submeter ou verificar
    buttons = driver.select_all("button")
    for button in buttons:
        if "verify" in button.text.lower() or "submit" in button.text.lower():
            button.click()
            driver.sleep(2)
            break

    return {"success": True, "token_length": len(token)}

# Execute o demo
result = solve_recaptcha_v3_with_api(data={
    "url": DEMO_URL,
    "site_key": DEMO_SITEKEY,
    "page_action": PAGE_ACTION
})

Resolvendo Cloudflare Turnstile com a API CapSolver

Cloudflare Turnstile é um alternativa de CAPTCHA focada na privacidade, projetada para ser menos intrusiva do que os CAPTCHAs tradicionais.

Diferenças principais em relação ao reCAPTCHA:

O tipo de tarefa é AntiTurnstileTaskProxyLess
O campo de resposta é token (não gRecaptchaResponse)
As chaves do site geralmente começam com 0x4

Encontrando a chave do site

Procure no HTML da página:

html Copy

<div class="cf-turnstile" data-sitekey="0x4AAAAAAABS7vwvV6VFfMcD"></div>

Função auxiliar

python Copy

def solve_turnstile(
    website_url: str,
    website_key: str,
    action: str = None,
    cdata: str = None,
    timeout: int = 120
) -> dict:
    """
Resolver o Cloudflare Turnstile usando a API do CapSolver.

    Args:
        website_url: A URL da página com Turnstile
        website_key: A chave do site Turnstile (começa com 0x4)
        action: Ação opcional do atributo data-action
        cdata: Dados adicionais opcionais do atributo data-cdata
        timeout: Tempo máximo para esperar pela solução (segundos)

    Returns:
        dict com o campo 'token'
    """

    if not Config.validate():
        raise Exception("Configuração inválida - verifique sua chave de API")

    # Construir o payload da tarefa
    task = {
        "type": "AntiTurnstileTaskProxyLess",
        "websiteURL": website_url,
        "websiteKey": website_key,
    }

    # Adicionar metadados opcionais
    metadata = {}
    if action:
        metadata["action"] = action
    if cdata:
        metadata["cdata"] = cdata

    if metadata:
        task["metadata"] = metadata

    payload = {
        "clientKey": Config.CAPSOLVER_API_KEY,
        "task": task
    }

    # Criar tarefa
    response = requests.post(Config.CREATE_TASK_ENDPOINT, json=payload)
    result = response.json()

    if result.get("errorId") and result.get("errorId") != 0:
        raise Exception(f"Falha ao criar tarefa: {result.get('errorDescription')}")

    task_id = result.get("taskId")

    # Verificar resultados
    start_time = time.time()
    while time.time() - start_time < timeout:
        time.sleep(2)

        result_payload = {
            "clientKey": Config.CAPSOLVER_API_KEY,
            "taskId": task_id
        }

        response = requests.post(Config.GET_RESULT_ENDPOINT, json=result_payload)
        result = response.json()

        if result.get("status") == "ready":
            return result.get("solution", {})

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

    raise Exception(f"Tempo esgotado após {timeout} segundos")

Exemplo Completo de Turnstile

python Copy

from botasaurus.browser import browser, Driver
from shared.config import Config
from utils.capsolver_helper import solve_turnstile

DEMO_URL = "https://peet.ws/turnstile-test/non-interactive.html"
DEMO_SITEKEY = "0x4AAAAAAABS7vwvV6VFfMcD"

@browser(headless=False)
def solve_turnstile_with_api(driver: Driver, data: dict):
    """Resolver o Cloudflare Turnstile usando a API do CapSolver e injetar o token."""

    url = data.get("url", DEMO_URL)
    site_key = data.get("site_key", DEMO_SITEKEY)

    # Passo 1: Carregar a página
    driver.get(url)
    driver.sleep(3)

    # Passo 2: Extrair a chave do site da página (opcional)
    extracted_params = driver.run_js("""
        const turnstileDiv = document.querySelector('.cf-turnstile, [data-sitekey]');
        if (turnstileDiv) {
            const key = turnstileDiv.getAttribute('data-sitekey');
            if (key && key.startsWith('0x')) {
                return {
                    sitekey: key,
                    action: turnstileDiv.getAttribute('data-action')
                };
            }
        }
        return null;
    """)

    if extracted_params and extracted_params.get("sitekey"):
        site_key = extracted_params["sitekey"]

    # Passo 3: Resolver Turnstile via API do CapSolver
    solution = solve_turnstile(
        website_url=url,
        website_key=site_key,
        action=extracted_params.get("action") if extracted_params else None
    )

    token = solution.get("token")

    # Passo 4: Injetar o token na página
    driver.run_js(f"""
        const token = "{token}";

        // Encontrar e preencher o campo cf-turnstile-response
        const responseFields = [
            document.querySelector('[name="cf-turnstile-response"]'),
            document.querySelector('[name="cf_turnstile_response"]'),
            document.querySelector('input[name*="turnstile"]')
        ];

        for (const field of responseFields) {{
            if (field) {{
                field.value = token;
                break;
            }}
        }}

        // Criar campo oculto se o formulário existir mas o campo não
        const forms = document.querySelectorAll('form');
        forms.forEach(form => {{
            let field = form.querySelector('[name="cf-turnstile-response"]');
            if (!field) {{
                field = document.createElement('input');
                field.type = 'hidden';
                field.name = 'cf-turnstile-response';
                form.appendChild(field);
            }}
            field.value = token;
        }});
    """)

    # Passo 5: Enviar o formulário
    submit_btn = driver.select('button[type="submit"], input[type="submit"]')
    if submit_btn:
        submit_btn.click()
        driver.sleep(2)

    return {"success": True, "token_length": len(token)}

# Executar o exemplo
result = solve_turnstile_with_api(data={"url": DEMO_URL, "site_key": DEMO_SITEKEY})

Referência de Tipos de Tarefa

Tipo de Captcha	Tipo de Tarefa	Campo de Resposta	Parâmetros Necessários
reCAPTCHA v2	`ReCaptchaV2TaskProxyLess`	`gRecaptchaResponse`	`websiteURL`, `websiteKey`
reCAPTCHA v2 Enterprise	`ReCaptchaV2EnterpriseTaskProxyLess`	`gRecaptchaResponse`	`websiteURL`, `websiteKey`
reCAPTCHA v3	`ReCaptchaV3TaskProxyLess`	`gRecaptchaResponse`	`websiteURL`, `websiteKey`, `pageAction`
reCAPTCHA v3 Enterprise	`ReCaptchaV3EnterpriseTaskProxyLess`	`gRecaptchaResponse`	`websiteURL`, `websiteKey`, `pageAction`
Cloudflare Turnstile	`AntiTurnstileTaskProxyLess`	`token`	`websiteURL`, `websiteKey`

Para sites que bloqueiam IPs de datacenter, use as variantes com proxy (ex.: ReCaptchaV2Task) e forneça seu próprio proxy residencial.

Práticas Recomendadas

1. Expiração do Token

Tokens de Captcha expiram rapidamente (geralmente em 2 minutos). Use sempre o token imediatamente após recebê-lo:

python Copy

# Obter token
solution = solve_recaptcha_v2(url, site_key)
token = solution.get("gRecaptchaResponse")

# Usar imediatamente - não armazene para depois
driver.run_js(f'document.querySelector("[name=g-recaptcha-response]").value = "{token}"')
driver.select('button[type="submit"]').click()

2. Tratamento de Erros

Sempre implemente tratamento adequado para falhas na API:

python Copy

try:
    solution = solve_recaptcha_v2(url, site_key)
except Exception as e:
    print(f"Falha ao resolver Captcha: {e}")
    # Implemente lógica de retry ou fallback

3. Limitação de Taxa

Adicione atrasos entre as requisições para evitar disparar medidas anti-bot:

python Copy

driver.sleep(2)  # Esperar após o carregamento da página
# ... resolver Captcha ...
driver.sleep(1)  # Esperar antes de enviar o formulário

4. Validar Configuração

Sempre valide sua chave de API antes de fazer requisições:

python Copy

if not Config.validate():
    raise Exception("Por favor, configure sua chave de API no arquivo .env")

Conclusão

Combinar o Botasaurus com a CapSolver fornece uma solução robusta para lidar com captchas em projetos de raspagem de web. A abordagem baseada em API oferece controle total sobre o processo de resolução e funciona de forma confiável em diferentes tipos de captchas.

Aumente seu orçamento de automação instantaneamente!
Use o código de bônus CAPN ao recarregar sua conta na CapSolver para obter um bônus extra de 5% em cada recarga — sem limites.
Resgate-o agora em seu Painel da CapSolver

Pontos Principais

O Botasaurus fornece automação de navegador com recursos embutidos de anti-deteção
A API da CapSolver oferece uma maneira confiável de resolver vários tipos de captchas de forma programática
O reCAPTCHA v2 requer os parâmetros websiteURL e websiteKey
O reCAPTCHA v3 requer adicionalmente um parâmetro pageAction
O Cloudflare Turnstile retorna um campo token em vez de gRecaptchaResponse
Tokens expiram rapidamente (~2 minutos), então devem ser usados imediatamente após recebê-los

Perguntas Frequentes (FAQ)

Como resolver reCAPTCHA e Cloudflare Turnstile automaticamente em raspagem de web com Python?

O método mais eficaz é usar um framework de automação de navegador robusto como o Botasaurus, que lida com anti-deteção, e integrá-lo com uma API dedicada de resolução de captchas como a CapSolver para obter de forma programática os tokens necessários.

Quais são os benefícios de usar o Botasaurus para raspagem de web com anti-deteção?

O Botasaurus simplifica a automação de navegador com uma API limpa baseada em decoradores, enquanto fornece recursos embutidos essenciais de stealth para minimizar o risco de ser detectado e bloqueado pelos sites-alvo.

Qual a diferença entre resolver reCAPTCHA v2 e v3 com a API da CapSolver?

Embora ambos exijam os parâmetros websiteURL e websiteKey, resolver o reCAPTCHA v3 (versão invisível baseada em pontuação) exige adicionalmente um parâmetro pageAction a ser incluído no payload da tarefa enviado para a API da CapSolver.

O que acontece depois que a CapSolver retorna um token de captcha?

Assim que o token (ex.: gRecaptchaResponse ou token) for recebido, ele deve ser imediatamente injetado no campo oculto da página-alvo usando um comando de execução de JavaScript antes que o formulário possa ser enviado com sucesso para o servidor.

Quanto tempo um token da CapSolver dura antes de expirar?

Os tokens de solução fornecidos pela CapSolver para reCAPTCHA e Turnstile têm um período de validade muito curto, geralmente expirando em aproximadamente 2 minutos, exigindo uso imediato após a recepção.

Declaração de Conformidade: As informações fornecidas neste blog são apenas para fins informativos. A CapSolver está comprometida em cumprir todas as leis e regulamentos aplicáveis. O uso da rede CapSolver para atividades ilegais, fraudulentas ou abusivas é estritamente proibido e será investigado. Nossas soluções de resolução de captcha melhoram a experiência do usuário enquanto garantem 100% de conformidade ao ajudar a resolver dificuldades de captcha durante a coleta de dados públicos. Incentivamos o uso responsável de nossos serviços. Para mais informações, visite nossos Termos de Serviço e Política de Privacidade.

Mais

Como resolver CAPTCHAs em Python Usando o Botasaurus e o CapSolver (Guia Completo)

Como resolver CAPTCHAs em Python usando Botasaurus e CapSolver (Guia Completo)

Aprenda a integrar o Botasaurus (framework de raspagem de web em Python) com a API do CapSolver para resolver automaticamente reCAPTCHA v2/v3 e Turnstile.

web scraping

Adélia Cruz

15-Dec-2025

Lumiproxy: Proxy Premium para Scraping de Web e Coleta de Dados

Neste artigo, mostraremos o que é Lumiproxy e os serviços que eles oferecem.

web scraping

Ethan Collins

12-Dec-2025

Tabproxy: Bom custo proxy residencial internacional

Neste artigo, vamos mostrar para você o que é o Tabproxy e os serviços que eles oferecem.

web scraping

Ethan Collins

12-Dec-2025

O que são erros 402, 403, 404 e 429 em raspagem de web? Um Guia Completo

Domine o tratamento de erros de raspagem de web entendendo o que são os erros 402, 403, 404 e 429. Aprenda a corrigir o erro 403 Proibido, implementar soluções para o erro de limitação de taxa 429 e tratar o código de status Payment Required emergente 402.

web scraping

Lucas Mitchell

12-Dec-2025

Proxies Residenciais IP2World: Soluções Líderes de Proxies IP Globais

Neste artigo, vamos mostrar o que é o IP2World e os serviços que eles oferecem.

web scraping

Ethan Collins

12-Dec-2025

Web Scraping com Python: 2026 Melhores Táticas

Aprenda as principais táticas de raspagem de web em Python para 2026, incluindo lidar com conteúdo JavaScript dinâmico, gerenciar fluxos de autenticação, resolver CAPTCHAs, identificar armadilhas ocultas, simular comportamento humano, otimizar padrões de requisição e reduzir o uso de recursos em projetos de raspagem em larga escala.

web scraping

Lucas Mitchell

12-Dec-2025