Lidando com CAPTCHAs ao Fazer Scraping

Por que CAPTCHAs São o maior obstáculo do raspador

Os CAPTCHAs existem para distinguir os seres humanos dos bots, e são cada vez mais eficazes. Quando seu raspador encontra um CAPTCHA, significa que o site alvo detectou comportamento automatizado — sua frequência de solicitação era muito alta, seu IP tem baixa confiança, ou sua impressão digital do navegador parecia suspeita. A melhor estratégia do CAPTCHA é a prevenção, não a resolução.

Este guia abrange os tipos de CAPTCHAs que você vai encontrar, por que a prevenção é mais eficaz e mais barato do que a resolução, e como os proxies desempenham um papel crítico em evitar CAPTCHAs inteiramente.

Este artigo faz parte do nosso Guia completo de Web Raspando Proxies série. Para compreender os sistemas de detecção, ver Como sistemas antibot detectam proxies.

Tipos de CAPTCHAs em 2026

CAPTCHAs invisíveis São a verdadeira ameaça

Os CAPTCHAs mais perigosos para raspadores são aqueles que você nunca vê. reCAPTCHA v3 e Turno de chama em nuvem correr em segundo plano, analisando movimentos do mouse, comportamento de rolagem, padrões de digitação e ambiente do navegador. Eles atribuem uma pontuação de confiança sem mostrar qualquer desafio - e se a pontuação é muito baixa, a solicitação é silenciosamente bloqueada ou redirecionada.

Prevenção vs Resolver: Por que a Prevenção Ganha

Em escala, a prevenção economiza dinheiro e tempo. Resolver 100.000 CAPTCHAs por dia custa $100-500 e adiciona horas de latência. Prevenir-lhes não custa nada extra além do correto proxy e gerenciamento de pedidos.

Estratégia de Prevenção 1: Usar Proxies Residenciais de Alta Qualidade

A medida de prevenção mais eficaz do CAPTCHA é o uso de proxies residenciais com altos escores de confiança. IPs residenciais são atribuídos a famílias reais por ISPs, então sites não podem facilmente distinguir suas solicitações de tráfego de usuário genuíno.

import requests
# Residential proxy — high trust score, fewer CAPTCHAs
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
def scrape_with_residential(url: str) -> str:
    """Use residential proxies to avoid triggering CAPTCHAs."""
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    session.headers.update({
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                      "AppleWebKit/537.36 (KHTML, like Gecko) "
                      "Chrome/120.0.0.0 Safari/537.36",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept-Encoding": "gzip, deflate, br",
    })
    resp = session.get(url, timeout=30)
    return resp.text

A piscina residencial do ProxyHat fornece IPs de ISPs reais em 190+ países, dando a cada solicitação o maior escore de confiança possível. Ver Residencial vs Datacenter Proxies para Raspamento para uma comparação detalhada.

Estratégia de prevenção 2: Padrões de solicitação realistas

CAPTCHAs são frequentemente desencadeadas por padrões de comportamento robótico, não apenas reputação IP. Faça seu raspador parecer humano:

Implementação em Python

import requests
import random
import time
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 Safari/605.1.15",
]
REFERRERS = [
    "https://www.google.com/",
    "https://www.bing.com/",
    "https://duckduckgo.com/",
    None,  # Direct visit
]
def human_like_scrape(urls: list[str]) -> list[str]:
    """Scrape with realistic human behavior patterns."""
    results = []
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    for url in urls:
        # Randomize headers per request
        headers = {
            "User-Agent": random.choice(USER_AGENTS),
            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
            "Accept-Language": "en-US,en;q=0.9",
            "Accept-Encoding": "gzip, deflate, br",
            "Connection": "keep-alive",
            "Upgrade-Insecure-Requests": "1",
        }
        referrer = random.choice(REFERRERS)
        if referrer:
            headers["Referer"] = referrer
        try:
            resp = session.get(url, headers=headers, timeout=30)
            results.append(resp.text)
        except requests.RequestException:
            results.append(None)
        # Human-like delays: 1-5 seconds with occasional longer pauses
        if random.random() < 0.1:
            time.sleep(random.uniform(5, 15))  # 10% chance of long pause
        else:
            time.sleep(random.uniform(1, 4))
    return results

Implementação Node.js

const HttpsProxyAgent = require('https-proxy-agent');
const fetch = require('node-fetch');
const agent = new HttpsProxyAgent('http://USERNAME:PASSWORD@gate.proxyhat.com:8080');
const USER_AGENTS = [
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
];
function randomDelay() {
  const isLongPause = Math.random() < 0.1;
  const ms = isLongPause
    ? 5000 + Math.random() * 10000
    : 1000 + Math.random() * 3000;
  return new Promise(r => setTimeout(r, ms));
}
async function humanLikeScrape(urls) {
  const results = [];
  for (const url of urls) {
    const headers = {
      'User-Agent': USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
      'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
      'Accept-Language': 'en-US,en;q=0.9',
    };
    try {
      const res = await fetch(url, { agent, headers, timeout: 30000 });
      results.push(await res.text());
    } catch {
      results.push(null);
    }
    await randomDelay();
  }
  return results;
}

Estratégia de prevenção 3: Rotação inteligente do IP

A forma como você gira IPs afeta diretamente as taxas de CAPTCHA. A rotação agressiva (novo IP cada pedido) pode realmente aumentar CAPTCHAs em alguns sites, porque uma série de pedidos de diferentes IPs acessando o mesmo caminho de sessão parece suspeito.

import requests
import uuid
def create_session_for_site(site_id: str):
    """Create a sticky session that maintains the same IP per site.
    This avoids the suspicious pattern of different IPs accessing the same flow."""
    session_id = uuid.uuid5(uuid.NAMESPACE_URL, site_id).hex[:8]
    proxy = f"http://USERNAME-session-{session_id}:PASSWORD@gate.proxyhat.com:8080"
    session = requests.Session()
    session.proxies = {"http": proxy, "https": proxy}
    return session
# Same IP for all requests to a specific product section
session = create_session_for_site("example.com-electronics")
page1 = session.get("https://example.com/electronics?page=1")
page2 = session.get("https://example.com/electronics?page=2")
page3 = session.get("https://example.com/electronics?page=3")
# Different IP for a different section
session2 = create_session_for_site("example.com-clothing")
clothes1 = session2.get("https://example.com/clothing?page=1")

Para mais padrões de rotação, ver Estratégias de rotação proxy para raspagem de grande escala.

Estratégia de prevenção 4: Limites de taxa de respeito

CAPTCHAs são muitas vezes o aumento após limitação de taxa. Se você lidar com sinais de limite de taxa corretamente, você raramente vê CAPTCHAs:

import requests
import time
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
CAPTCHA_INDICATORS = [
    "captcha",
    "recaptcha",
    "hcaptcha",
    "challenge",
    "verify you are human",
    "please complete the security check",
]
def is_captcha_page(html: str) -> bool:
    """Detect if the response is a CAPTCHA challenge page."""
    html_lower = html.lower()
    return any(indicator in html_lower for indicator in CAPTCHA_INDICATORS)
def scrape_with_captcha_detection(urls: list[str]) -> list[dict]:
    results = []
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    captcha_count = 0
    backoff = 2.0
    for url in urls:
        try:
            resp = session.get(url, timeout=30)
            if resp.status_code == 200 and not is_captcha_page(resp.text):
                results.append({"url": url, "status": "success", "body": resp.text})
                captcha_count = 0
                backoff = max(backoff * 0.9, 1.0)  # Reduce backoff on success
            elif is_captcha_page(resp.text) or resp.status_code == 403:
                captcha_count += 1
                results.append({"url": url, "status": "captcha"})
                if captcha_count >= 3:
                    # Too many CAPTCHAs — increase backoff significantly
                    backoff = min(backoff * 3, 60)
                    print(f"CAPTCHA streak: {captcha_count}. Backing off to {backoff:.0f}s")
                else:
                    backoff = min(backoff * 1.5, 30)
        except requests.RequestException as e:
            results.append({"url": url, "status": "error", "error": str(e)})
        time.sleep(backoff)
    return results

Para estratégias abrangentes de limite de taxa, ver Limites de taxa de raspagem explicados.

Quando você deve lidar com CAPTCHAs: detecção e roteamento

Mesmo com a prevenção perfeita, alguns CAPTCHAs são inevitáveis. Construa a detecção em seu oleoduto para que você possa encaminhar páginas CAPTCHA para manuseio especial:

import requests
from enum import Enum
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
class ResponseType(Enum):
    SUCCESS = "success"
    CAPTCHA = "captcha"
    BLOCKED = "blocked"
    ERROR = "error"
def classify_response(resp: requests.Response) -> ResponseType:
    """Classify a response to determine next action."""
    if resp.status_code == 403:
        return ResponseType.BLOCKED
    if resp.status_code == 429:
        return ResponseType.BLOCKED
    if resp.status_code == 200:
        html = resp.text.lower()
        captcha_signals = ["captcha", "recaptcha", "hcaptcha", "cf-challenge"]
        if any(s in html for s in captcha_signals):
            return ResponseType.CAPTCHA
        return ResponseType.SUCCESS
    return ResponseType.ERROR
def scrape_with_routing(urls: list[str]) -> dict:
    """Scrape URLs and route based on response classification."""
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    results = {"success": [], "captcha": [], "blocked": [], "error": []}
    for url in urls:
        try:
            resp = session.get(url, timeout=30)
            response_type = classify_response(resp)
            results[response_type.value].append(url)
            if response_type == ResponseType.CAPTCHA:
                # Route to CAPTCHA queue for manual or service-based solving
                print(f"CAPTCHA detected: {url}")
            elif response_type == ResponseType.BLOCKED:
                # Rotate IP and retry
                print(f"Blocked: {url}")
        except requests.RequestException:
            results["error"].append(url)
    print(f"Success: {len(results['success'])}, "
          f"CAPTCHAs: {len(results['captcha'])}, "
          f"Blocked: {len(results['blocked'])}")
    return results

Lista de Verificação de Prevenção CAPTCHA

• Use proxies residenciais. Eles têm os maiores escores de confiança e desencadeiam os CAPTCHAs mais escassos. ProxyHat proxies residenciais fornecer milhões de IPs limpos.
• Definir cabeçalhos realistas. Envie sempre os cabeçalhos do usuário, aceite, aceite a linguagem e outros cabeçalhos padrão do navegador.
• Adicione atrasos humanos. Atrasos aleatórios de 1-5 segundos entre pedidos com pausas ocasionais mais longas.
• Mantenha as sessões corretamente. Use cookies e IPs consistentes para solicitações relacionadas através de sessões pegajosas.
• Respeite robots.txt. Sites que detectam violações de robôs.txt aumentam para CAPTCHAs mais rápido.
• Monitorar as taxas de CAPTCHA. Se sua taxa CAPTCHA exceder 5%, algo em sua abordagem precisa ser corrigido.
• Evite raspar durante as horas de pico. Os sistemas anti-bots são mais agressivos durante períodos de alto tráfego.
• Rodar os Agentes do Usuário corretamente. Use strings de navegador recentes e realistas. Não misture UAs móveis e desktop na mesma sessão.

Para configuração do proxy no seu idioma preferido, consulte Usando Proxies em Python, Usando Proxies em Node.js, ou Usando Proxies em Go. Explorar ProxyHat para raspar Web para começar.

Perguntas Frequentes

Proxies podem ajudar a evitar CAPTCHAs?

Sim, significativamente. Proxies residenciais de alta qualidade têm reputação IP limpa que raramente disparam CAPTCHAs. Os IPs do Datacenter são marcados mais frequentemente porque são fontes automatizadas conhecidas. A combinação de proxies residenciais com padrões de solicitação adequados praticamente elimina CAPTCHAs para a maioria dos alvos.

Qual é a maneira mais barata de lidar com CAPTCHAs em escala?

Prevenção. Investir em proxies residenciais e padrões de raspagem adequados custa muito menos do que os serviços de resolução CAPTCHA em escala. Se você precisa resolver CAPTCHAs, serviços de terceiros custam US $ 1-3 por 1.000, mas adicionar 10-60 segundos de latência por solicitação.

Navegadores sem cabeça ajudam com CAPTCHAs?

Eles ajudam com CAPTCHAs invisíveis (reCAPTCHA v3, Turnstile) fornecendo um ambiente de navegador real com execução JavaScript. No entanto, são mais lentos e mais intensivos em recursos. Use-os apenas para alvos que exigem especificamente verificação de nível do navegador.

Como sei se estou recebendo páginas do CAPTCHA?

Verificar resposta HTML para indicadores CAPTCHA: "capta", "recapta", "hcapta", "desafio", ou "verificar você é humano". Também observe respostas inesperadas de 403 e redirecione para URLs de desafio. Crie detecção automatizada no seu oleoduto de raspagem.

Por que ainda tenho CAPTCHAs com proxies residenciais?

Normalmente por causa de padrões de solicitação, não qualidade IP. Causas comuns: muitos pedidos por minuto, cabeçalhos de navegador ausentes, problemas de manuseio de cookies ou padrões de raspagem que são muito sistemáticos. Devagar, adicione jitter e use sessões pegajosas para solicitações relacionadas.