Raspagem de sites protegidos por CAPTCHA

A maioria dos sites de alto valor usa CAPTCHAs como parte de sua defesa anti-bot. Este guia aborda estratégias para raspar esses sites de maneira confiável usando CaptchaAI, incluindo como identificar tipos de CAPTCHA, resolvê-los automaticamente e construir raspadores resilientes.

Implementações comuns de CAPTCHA

Estratégia 1: Detectar e resolver sob demanda

A abordagem mais confiável – raspar normalmente e resolver CAPTCHAs somente quando eles aparecerem:

import requests
import time
from bs4 import BeautifulSoup

API_KEY = "YOUR_API_KEY"

class ProtectedScraper:
    def __init__(self):
        self.session = requests.Session()
        self.session.headers.update({
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
        })

    def scrape(self, url):
        resp = self.session.get(url)

        # Check for CAPTCHA
        if self._has_captcha(resp.text):
            resp = self._handle_captcha(resp.text, url)

        return resp.text

    def _has_captcha(self, html):
        indicators = ["g-recaptcha", "cf-turnstile", "h-captcha", "captcha"]
        return any(ind in html.lower() for ind in indicators)

    def _handle_captcha(self, html, url):
        soup = BeautifulSoup(html, "html.parser")

        # reCAPTCHA v2
        rc = soup.find("div", class_="g-recaptcha")
        if rc:
            token = self._solve_recaptcha(rc["data-sitekey"], url)
            return self.session.post(url, data={"g-recaptcha-response": token})

        # Cloudflare Turnstile
        ts = soup.find("div", class_="cf-turnstile")
        if ts:
            token = self._solve_turnstile(ts["data-sitekey"], url)
            return self.session.post(url, data={"cf-turnstile-response": token})

        raise Exception("Unknown CAPTCHA type")

    def _solve_recaptcha(self, site_key, page_url):
        resp = requests.get("https://ocr.captchaai.com/in.php", params={
            "key": API_KEY, "method": "userrecaptcha",
            "googlekey": site_key, "pageurl": page_url
        })
        return self._poll(resp.text.split("|")[1])

    def _solve_turnstile(self, site_key, page_url):
        resp = requests.get("https://ocr.captchaai.com/in.php", params={
            "key": API_KEY, "method": "turnstile",
            "sitekey": site_key, "pageurl": page_url
        })
        return self._poll(resp.text.split("|")[1])

    def _poll(self, task_id):
        for _ in range(60):
            time.sleep(5)
            result = requests.get("https://ocr.captchaai.com/res.php", params={
                "key": API_KEY, "action": "get", "id": task_id
            })
            if result.text == "CAPCHA_NOT_READY": continue
            if result.text.startswith("OK|"): return result.text.split("|")[1]
            raise Exception(result.text)
        raise TimeoutError()

# Usage
scraper = ProtectedScraper()
html = scraper.scrape("https://example.com/data")

Estratégia 2: Pré-solução para páginas CAPTCHA conhecidas

Se você sabe quais páginas sempre possuem CAPTCHAs, resolva preventivamente:

def scrape_known_captcha_page(url, site_key):
    # Solve before even loading the page
    token = solve_recaptcha(site_key, url)

    # Submit directly with token
    resp = requests.post(url, data={
        "g-recaptcha-response": token,
        "query": "search term"
    })
    return resp.text

Estratégia 3: Sites protegidos pela Cloudflare

Os sites por trás do Cloudflare geralmente exigem um cookie cookie_qa_validacao:

def get_cloudflare_clearance(url, proxy):
    resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY,
        "method": "turnstile_staging",
        "pageurl": url,
        "proxy": proxy,
        "proxytype": "HTTP"
    })
    task_id = resp.text.split("|")[1]

    for _ in range(60):
        time.sleep(5)
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY, "action": "get", "id": task_id
        })
        if result.text == "CAPCHA_NOT_READY": continue
        if "cookie_qa_validacao" in result.text:
            # Parse cookie_qa_validacao and user_agent from response
            return result.text
    raise TimeoutError()

Padrão de raspagem de várias páginas

def scrape_multiple_pages(base_url, site_key, pages):
    scraper = ProtectedScraper()
    results = []

    for page in pages:
        url = f"{base_url}?page={page}"
        try:
            html = scraper.scrape(url)
            soup = BeautifulSoup(html, "html.parser")
            items = soup.find_all("div", class_="item")
            results.extend([item.text.strip() for item in items])
            print(f"Page {page}: {len(items)} items")
        except Exception as e:
            print(f"Page {page} failed: {e}")

        time.sleep(random.uniform(2, 5))

    return results

Solução de problemas

Perguntas frequentes

Quais sites são mais difíceis de raspar?

Sites que usam Cloudflare Enterprise, PerimeterX ou Akamai Bot Manager são os mais desafiadores. CaptchaAI lida com seus componentes CAPTCHA; combine com navegadores controle de QAs e proxies para obter mais adequado resultados.

Posso raspar sites que exigem login?

Sim. Faça login primeiro (resolvendo qualquer CAPTCHA de login), mantenha os cookies da sessão e, em seguida, limpe as páginas autenticadas. CaptchaAI lida com CAPTCHAs em qualquer estágio.

Como lidar com páginas renderizadas em JavaScript?

Use Selenium, Puppeteer ou Playwright para renderizar JavaScript, depois extraia os parâmetros CAPTCHA e resolva via CaptchaAI. VerManipulação de selênio CAPTCHA.

Guias Relacionados

• Como lidar com os desafios do CAPTCHA em fluxos de trabalho de coleta autorizada
• Problemas de CAPTCHA do navegador modo headless
• Explicação da detecção de CAPTCHA em raspagem