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?

web scraping

Rajinder Singh

15-Jan-2026

Scrapy vs. Selenium: Qual é o melhor para o seu projeto de raspagem de web

Descubra as vantagens e diferenças entre o Scrapy e o Selenium para raspagem de dados. Aprenda qual ferramenta é a mais adequada para o seu projeto e como lidar com desafios como CAPTCHAs.

web scraping

Anh Tuan

14-Jan-2026