Como reduzir a taxa de banimento em web scraping para 5%: 12 métodos comprovados de proteção

Se você trabalha com scraping de marketplaces, monitoramento de preços de concorrentes ou coleta de dados de sites, conhece o problema: sites bloqueiam endereços IP, exigem captcha ou retornam páginas vazias. A taxa de banimento (percentual de requisições bloqueadas) pode chegar a 70-90%, tornando o scraping impossível. Neste artigo, vamos analisar métodos concretos que ajudarão a reduzir a taxa de banimento para 5-10% e coletar dados de forma estável.

Vamos examinar tanto soluções técnicas (rotação de proxy, cabeçalhos HTTP, fingerprinting) quanto padrões comportamentais (atrasos, imitação de ações do usuário). Todos os métodos foram testados na prática no scraping de Wildberries, Ozon, Avito e plataformas internacionais.

Por que sites bloqueiam scrapers: principais gatilhos

Antes de analisar os métodos de proteção, é importante entender como os sites identificam tráfego automatizado. Sistemas anti-bot modernos (Cloudflare, Akamai, DataDome, Imperva) analisam dezenas de parâmetros de cada requisição. Aqui estão os principais gatilhos de bloqueio:

Por exemplo, ao fazer scraping do Wildberries, um erro típico é enviar requisições a cada 0,5 segundos do mesmo IP. O sistema anti-bot Cloudflare identificará instantaneamente o padrão e bloqueará o IP por 24 horas. Um usuário real gasta 5-15 segundos visualizando um cartão de produto, rola a página, clica nas imagens.

Rotação de proxy: como alternar endereços IP corretamente

O uso de proxies é um método básico para reduzir a taxa de banimento. Mas é importante não apenas comprar proxies, mas configurar a rotação corretamente. Aqui estão estratégias comprovadas:

Escolha do tipo de proxy para scraping

Para scraping de marketplaces (Wildberries, Ozon, Avito), são recomendados proxies residenciais — eles têm IPs de usuários domésticos reais, que são difíceis de distinguir do tráfego normal. Proxies de data center são adequados para sites menos protegidos ou quando é necessária velocidade máxima com grande volume de dados.

Estratégias de rotação de endereços IP

Tamanho do pool de proxies

O tamanho mínimo do pool depende da intensidade do scraping:

• Baixa intensidade (até 10.000 requisições por dia): 10-20 proxies
• Intensidade média (10.000 - 100.000 requisições por dia): 50-100 proxies
• Alta intensidade (mais de 100.000 requisições por dia): 200+ proxies ou residenciais com rotação automática

Para proxies residenciais com rotação a cada requisição (rotating proxies), o tamanho do pool pode ser menor, pois o provedor substitui automaticamente por um novo IP de seu pool de milhões de endereços.

User-Agent e cabeçalhos HTTP: imitando um navegador real

Mesmo com bons proxies, você pode ser bloqueado se os cabeçalhos HTTP parecerem suspeitos. Sites analisam não apenas o User-Agent, mas também a ordem dos cabeçalhos, seus valores e correspondência entre si.

User-Agent correto

Não use o mesmo User-Agent para todas as requisições. Crie uma lista de navegadores populares e escolha aleatoriamente:

user_agents = [
    # Chrome no Windows
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    # Chrome no macOS
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    # Firefox no Windows
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
    # Safari no macOS
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15",
    # Edge no Windows
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0"
]

Conjunto completo de cabeçalhos HTTP

Navegadores modernos enviam 15-20 cabeçalhos. Aqui está o conjunto mínimo necessário para imitar o Chrome:

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
    "Accept-Language": "pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7",
    "Accept-Encoding": "gzip, deflate, br",
    "DNT": "1",
    "Connection": "keep-alive",
    "Upgrade-Insecure-Requests": "1",
    "Sec-Fetch-Dest": "document",
    "Sec-Fetch-Mode": "navigate",
    "Sec-Fetch-Site": "none",
    "Sec-Fetch-User": "?1",
    "Cache-Control": "max-age=0",
    "sec-ch-ua": '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
    "sec-ch-ua-mobile": "?0",
    "sec-ch-ua-platform": '"Windows"'
}

Observe os cabeçalhos Sec-Fetch-* e sec-ch-ua-* — eles apareceram nas novas versões do Chrome e sua ausência pode revelar automação.

A ordem dos cabeçalhos importa

Navegadores enviam cabeçalhos em uma ordem específica. Por exemplo, o Chrome sempre coloca Host primeiro, depois Connection, User-Agent e assim por diante. Se você usar a biblioteca requests do Python, a ordem pode ser alfabética, o que revelará automação.

Solução: use bibliotecas que formam cabeçalhos corretamente (curl_cffi para Python, got para Node.js) ou navegadores headless (Puppeteer, Playwright, Selenium), que geram cabeçalhos como um navegador real.

Atrasos entre requisições: intervalos ideais

Um dos métodos mais simples, mas eficazes, para reduzir a taxa de banimento são os atrasos corretos entre requisições. Um usuário real não pode abrir 10 páginas por segundo, portanto requisições muito rápidas causam bloqueio instantâneo.

Atrasos aleatórios em vez de fixos

Não use atraso fixo (por exemplo, exatamente 2 segundos entre requisições). Sistemas anti-bot identificam facilmente esse padrão. Use intervalo aleatório:

import random
import time

# Em vez de atraso fixo
time.sleep(2)  # ❌ Ruim

# Use intervalo aleatório
delay = random.uniform(2.5, 5.5)  # ✅ Bom
time.sleep(delay)

Intervalos recomendados para diferentes sites

Atrasos adaptativos baseados em respostas do servidor

Abordagem avançada — alterar dinamicamente os atrasos dependendo das respostas do servidor:

base_delay = 3.0  # Atraso base
delay_multiplier = 1.0

response = requests.get(url, headers=headers, proxies=proxies)

# Se recebeu captcha ou 429 — aumenta o atraso
if response.status_code == 429 or 'captcha' in response.text.lower():
    delay_multiplier *= 1.5
    print(f"Proteção detectada, aumentando atraso para {base_delay * delay_multiplier}s")

# Se tudo está bem — pode acelerar um pouco
elif response.status_code == 200:
    delay_multiplier = max(1.0, delay_multiplier * 0.95)

time.sleep(random.uniform(base_delay * delay_multiplier, base_delay * delay_multiplier * 1.5))

Esta abordagem permite desacelerar automaticamente ao detectar proteção e acelerar quando o site não mostra agressividade.

Proteção contra fingerprinting: Canvas, WebGL, fontes

Se o site usa JavaScript para verificação, cabeçalhos HTTP simples não são suficientes. Sistemas anti-bot modernos criam uma "impressão digital" do navegador (fingerprint) baseada em dezenas de parâmetros: Canvas, WebGL, fontes instaladas, fuso horário, resolução de tela e outros.

Principais parâmetros de fingerprinting

Ferramentas para bypass de fingerprinting

Para bypass de fingerprinting, use ferramentas especializadas:

• Undetected ChromeDriver (Python) — versão modificada do Selenium que oculta sinais de automação
• Puppeteer Stealth (Node.js) — plugin para Puppeteer que substitui parâmetros de fingerprint
• Playwright com stealth — similar ao Puppeteer, mas com melhor suporte para diferentes navegadores
• Navegadores antidetecção (Dolphin Anty, AdsPower, Multilogin) — para quem não quer escrever código, esses navegadores substituem automaticamente o fingerprint

Exemplo de uso do undetected-chromedriver em Python:

import undetected_chromedriver as uc

# Cria navegador com proteção contra detecção
options = uc.ChromeOptions()
options.add_argument('--disable-blink-features=AutomationControlled')

driver = uc.Chrome(options=options)
driver.get('https://example.com')

# Verifica que navigator.webdriver === undefined
webdriver_status = driver.execute_script("return navigator.webdriver")
print(f"navigator.webdriver: {webdriver_status}")  # Deve ser None/undefined

Gerenciamento de cookies e sessões

Muitos sites usam cookies para rastrear o comportamento dos usuários. O gerenciamento correto de cookies ajuda a evitar bloqueios e parecer um usuário real.

Salvando e reutilizando cookies

Em vez de criar uma nova sessão a cada requisição, salve cookies e reutilize-os. Isso imita o comportamento de um usuário real que retorna ao site:

import requests
import pickle

session = requests.Session()

# Primeira visita — obtém cookies
response = session.get('https://example.com')

# Salva cookies em arquivo
with open('cookies.pkl', 'wb') as f:
    pickle.dump(session.cookies, f)

# Depois carrega cookies
with open('cookies.pkl', 'rb') as f:
    session.cookies.update(pickle.load(f))

# Agora as requisições parecem de um usuário que retornou
response = session.get('https://example.com/catalog')

Aquecimento de sessão antes do scraping

Não comece o scraping imediatamente nas páginas alvo. Imite o comportamento de um usuário real:

1. Abra a página inicial do site
2. Aguarde 2-5 segundos
3. Abra a página de categoria ou seção
4. Aguarde 3-7 segundos
5. Só depois disso comece a fazer scraping das páginas alvo

Isso cria um histórico de atividade nos cookies e reduz a probabilidade de bloqueio.

Processamento de session cookies e tokens

Alguns sites geram tokens únicos na primeira visita e os verificam em requisições subsequentes. Por exemplo, o Wildberries usa um token no cabeçalho x-requested-with. Sempre salve esses tokens da primeira resposta e envie-os em requisições subsequentes.

Renderização de JavaScript: quando é necessária

Muitos sites modernos carregam conteúdo via JavaScript. Se você usar um cliente HTTP simples (requests em Python, axios em Node.js), receberá uma página vazia ou placeholder. Nesses casos, a renderização de JavaScript é necessária.

Quando a renderização de JavaScript é necessária

• O site usa React, Vue, Angular — o conteúdo é carregado após o carregamento inicial da página
• Dados são carregados via requisições AJAX/Fetch
• O site requer execução de JavaScript para gerar tokens ou cookies
• Há proteção contra bots que requer execução de código JS (por exemplo, Cloudflare Challenge)

Ferramentas para renderização de JavaScript

Para a maioria das tarefas, recomenda-se o Playwright — é mais rápido que o Selenium, faz melhor bypass de proteção e tem uma API mais conveniente.

Alternativa: interceptação de requisições API

Frequentemente é possível evitar a renderização de JavaScript se você encontrar as requisições API que o site usa para carregar dados. Abra DevTools (F12) → aba Network → filtro XHR/Fetch e veja quais requisições o site envia. Depois repita essas requisições diretamente via cliente HTTP.

Exemplo: O Wildberries carrega dados de produtos via API https://catalog.wb.ru/catalog/.... Em vez de renderizar a página inteira, você pode requisitar essa API diretamente, o que é 10-20 vezes mais rápido.

Bypass de captcha: soluções automáticas

Mesmo com proxies e cabeçalhos corretos, você pode encontrar captcha. Existem várias abordagens para resolvê-la:

Tipos de captcha e métodos de solução

Integração de serviço de reconhecimento de captcha

Exemplo de integração do 2Captcha em Python:

from twocaptcha import TwoCaptcha

solver = TwoCaptcha('YOUR_API_KEY')

try:
    # Resolve reCAPTCHA v2
    result = solver.recaptcha(
        sitekey='6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
        url='https://example.com'
    )
    
    # Obtém token da solução
    captcha_token = result['code']
    
    # Envia formulário com token
    response = requests.post('https://example.com/submit', data={
        'g-recaptcha-response': captcha_token
    })
    
except Exception as e:
    print(f"Erro ao resolver captcha: {e}")

Rate limiting: como não exceder os limites do site

Muitos sites têm limites explícitos ou implícitos no número de requisições. Exceder esses limites leva ao bloqueio temporário ou permanente do IP.

Determinando os limites do site

Preste atenção aos cabeçalhos HTTP nas respostas do servidor:

• X-RateLimit-Limit — número máximo de requisições no período
• X-RateLimit-Remaining — quantas requisições restam
• X-RateLimit-Reset — quando o limite será resetado (Unix timestamp)
• Retry-After — após quantos segundos pode repetir a requisição

Se você recebeu o código de status 429 (Too Many Requests), isso significa que o limite foi excedido. Leia o cabeçalho Retry-After e aguarde o tempo indicado antes da próxima requisição.

Implementação de rate limiter

Crie um mecanismo de controle de velocidade de requisições:

import time
from collections import deque

class RateLimiter:
    def __init__(self, max_requests, time_window):
        """
        max_requests: número máximo de requisições
        time_window: janela de tempo em segundos
        """
        self.max_requests = max_requests
        self.time_window = time_window
        self.requests = deque()
    
    def wait_if_needed(self):
        now = time.time()
        
        # Remove requisições antigas fora da janela de tempo
        while self.requests and self.requests[0] < now - self.time_window:
            self.requests.popleft()
        
        # Se atingiu o limite, aguarda
        if len(self.requests) >= self.max_requests:
            sleep_time = self.time_window - (now - self.requests[0])
            if sleep_time > 0:
                print(f"Limite atingido, aguardando {sleep_time:.2f}s")
                time.sleep(sleep_time)
                self.requests.popleft()
        
        # Registra nova requisição
        self.requests.append(time.time())

# Uso: máximo 60 requisições por minuto
limiter = RateLimiter(max_requests=60, time_window=60)

for url in urls:
    limiter.wait_if_needed()
    response = requests.get(url)

Monitoramento de métricas: rastreando a taxa de banimento

Para entender a eficácia dos métodos de proteção, é necessário monitorar constantemente as métricas do scraping. Aqui estão os principais indicadores:

Principais métricas para rastreamento

Implementação de sistema de monitoramento

class ScraperMetrics:
    def __init__(self):
        self.total_requests = 0
        self.successful_requests = 0
        self.blocked_requests = 0
        self.captcha_requests = 0
        self.response_times = []
    
    def record_request(self, status_code, response_time, has_captcha=False):
        self.total_requests += 1
        self.response_times.append(response_time)
        
        if status_code == 200 and not has_captcha:
            self.successful_requests += 1
        elif status_code in [403, 429] or has_captcha:
            if has_captcha:
                self.captcha_requests += 1
            else:
                self.blocked_requests += 1
    
    def get_stats(self):
        if self.total_requests == 0:
            return {}
        
        return {
            'total_requests': self.total_requests,
            'success_rate': (self.successful_requests / self.total_requests) * 100,
            'ban_rate': (self.blocked_requests / self.total_requests) * 100,
            'captcha_rate': (self.captcha_requests / self.total_requests) * 100,
            'avg_response_time': sum(self.response_times) / len(self.response_times)
        }
    
    def print_stats(self):
        stats = self.get_stats()
        print(f"\n=== Estatísticas de Scraping ===")
        print(f"Total de requisições: {stats['total_requests']}")
        print(f"Taxa de sucesso: {stats['success_rate']:.2f}%")
        print(f"Taxa de banimento: {stats['ban_rate']:.2f}%")
        print(f"Taxa de captcha: {stats['captcha_rate']:.2f}%")
        print(f"Tempo médio de resposta: {stats['avg_response_time']:.2f}s")

# Uso
metrics = ScraperMetrics()

for url in urls:
    start_time = time.time()
    response = requests.get(url)
    response_time = time.time() - start_time
    
    has_captcha = 'captcha' in response.text.lower()
    metrics.record_request(response.status_code, response_time, has_captcha)
    
    # Exibe estatísticas a cada 100 requisições
    if metrics.total_requests % 100 == 0:
        metrics.print_stats()

Comparação de ferramentas para scraping

Escolher a ferramenta certa pode reduzir significativamente a taxa de banimento. Aqui está uma comparação das soluções mais populares:

Recomendações de escolha

• Para iniciantes: Comece com Requests + proxies residenciais. Simples de configurar, adequado para sites com proteção fraca.
• Para projetos médios: Use Scrapy com middleware para rotação de proxies e User-Agent. Boa relação velocidade/confiabilidade.
• Para sites com proteção forte: Playwright com stealth ou navegadores antidetecção. Maior taxa de sucesso, mas mais lento.
• Para quem não quer configurar: Serviços prontos como ScrapingBee ou ScraperAPI. Caro, mas funciona imediatamente.

Conclusão

Reduzir a taxa de banimento no web scraping é uma tarefa complexa que requer uma abordagem integrada. Não existe uma "bala de prata" — você precisa combinar vários métodos:

1. Proxies de qualidade — a base de qualquer scraping. Prefira proxies residenciais para sites com proteção.
2. Cabeçalhos HTTP corretos — imite um navegador real, não apenas no User-Agent, mas em todos os cabeçalhos.
3. Atrasos aleatórios — não se apresse, imite o comportamento de um usuário real.
4. Proteção contra fingerprinting — use ferramentas especializadas para ocultar sinais de automação.
5. Gerenciamento de cookies — mantenha sessões, aqueça antes do scraping.
6. Monitoramento de métricas — rastreie constantemente a taxa de banimento e ajuste a estratégia.

Lembre-se: o objetivo não é enganar completamente o sistema de proteção, mas parecer o mais próximo possível de um usuário real. Quanto mais natural for o comportamento do seu scraper, menor será a taxa de banimento.

Se você precisa de proxies confiáveis para scraping, confira nossa seleção de proxies residenciais com baixa taxa de banimento e suporte para os principais marketplaces.