Como evitar bloqueios ao fazer solicitações frequentes à API do Wildberries, Ozon e Avito

Se você está monitorando os preços dos concorrentes, fazendo scraping de estoques de produtos ou publicando anúncios automaticamente em marketplaces — você certamente já se deparou com bloqueios. A API do Wildberries, Ozon, Yandex.Market e Avito se protegem ativamente contra automação: limitam o número de solicitações, bloqueiam endereços IP e exigem CAPTCHA. Neste guia, vamos analisar por que ocorrem bloqueios e como configurar o scraper para trabalhar de forma estável por meses sem bans.

Por que os marketplaces bloqueiam solicitações frequentes à API

Os marketplaces gastam enormes quantias de dinheiro para manter a infraestrutura — servidores, bancos de dados, CDN. Quando você faz milhares de solicitações por minuto para scraping de preços, você cria uma carga adicional em seus sistemas. Mas a principal razão para os bloqueios não é técnica, mas orientada para negócios.

Principais razões para bloqueios:

• Proteção de dados competitivos. Wildberries e Ozon não querem que os concorrentes obtenham facilmente informações sobre preços, estoques e produtos populares. Esses dados são segredos comerciais.
• Redução da carga nos servidores. Um scraper pode gerar tantas solicitações quanto 10.000 compradores comuns. Isso aumenta os custos de hospedagem.
• Luta contra fraudes e spam. Sistemas automáticos são usados para inflar visualizações, avaliações e publicação em massa de anúncios no Avito.
• Monetização da API. Alguns marketplaces oferecem APIs pagas oficiais com limites. Ao bloquear scraping gratuito, eles incentivam a compra de acesso.

Por exemplo, se você monitora preços de 5.000 produtos a cada hora — isso resulta em 120.000 solicitações por dia. De um único endereço IP, isso parece suspeito, e o sistema de proteção do marketplace rapidamente bloqueará seu acesso.

Quais métodos de proteção usam Wildberries, Ozon e Avito

Os marketplaces modernos utilizam proteção em múltiplas camadas contra scraping. Compreender esses mecanismos ajudará a configurar corretamente a contorno de bloqueios.

Wildberries utiliza proteção agressiva: limite de cerca de 200-300 solicitações por hora de um único IP, verificação de User-Agent e desafios de JavaScript. Ao exceder o limite, você receberá HTTP 429 (Too Many Requests) ou 403 (Forbidden).

Ozon é mais permissivo em relação ao scraping via API, mas bloqueia ativamente IPs de data centers. Eles usam serviços de identificação de tipo de IP (DataCenter vs Residential), portanto, proxies comuns frequentemente não funcionam.

Avito protege a API contra a publicação em massa de anúncios e scraping de contatos. Aqui, a vinculação geográfica é importante: se você publica um anúncio em Kazan, o IP deve ser de Kazan, caso contrário, a moderação bloqueará a publicação.

Limitação de taxa: como configurar corretamente os delays entre as solicitações

Limitação de taxa é uma restrição artificial na velocidade das solicitações, para que sua atividade pareça com as ações de um usuário comum. A regra principal: é melhor ser lento, mas estável, do que rápido e com ban.

Configurações recomendadas para marketplaces populares:

Como implementar delays randomizados: Não use intervalos fixos como "exatamente 3 segundos" — isso parece um bot. Adicione aleatoriedade: de 2 a 5 segundos. A maioria dos scrapers suporta isso através das configurações.

Por exemplo, em Python com a biblioteca requests, isso se parece com:

import time
import random
import requests

def make_request(url, proxies):
    response = requests.get(url, proxies=proxies)
    # Delay random de 2 a 5 segundos
    delay = random.uniform(2.0, 5.0)
    time.sleep(delay)
    return response

# Exemplo de uso
proxy = {
    'http': 'http://username:password@proxy.example.com:8000',
    'https': 'http://username:password@proxy.example.com:8000'
}

for product_id in product_list:
    url = f'https://card.wb.ru/cards/detail?nm={product_id}'
    response = make_request(url, proxy)
    # Processamento de dados...

Ponto importante: Após cada 100-200 solicitações, faça uma pausa longa (10-20 minutos) ou mude o IP. Isso simula o comportamento de uma pessoa que está navegando por produtos e depois se distrai com outras tarefas.

Rotação de proxies para distribuição de carga

Mesmo com os delays corretos, um único IP não suportará uma carga prolongada. A solução é a rotação de proxies: distribuição de solicitações entre vários endereços IP. Esta é a base para um scraping estável em marketplaces.

Tipos de proxies para scraping de marketplaces:

Para scraping do Wildberries e Ozon, recomendamos usar proxies residenciais — eles têm IPs de usuários domésticos reais, portanto, os marketplaces não conseguem diferenciá-los de compradores comuns. Proxies de data centers funcionam mal aqui: Ozon e Wildberries mantêm listas negras desses IPs.

Estratégias de rotação de proxies:

• Rotação após N solicitações. Mude o IP após cada 100-300 solicitações. Este é o equilíbrio ideal entre eficiência e segurança.
• Rotação por tempo. Mude o IP a cada 30-60 minutos. Adequado para longas sessões de scraping.
• Sticky sessions. Use um IP para todas as solicitações a um produto/categoria, depois mude. Isso reduz a suspeita.
• Vinculação geográfica. Para Avito é obrigatório: faça scraping de anúncios de Moscovo através de IPs de Moscovo, de Kazan — através de IPs de Kazan.

A maioria dos provedores de proxies residenciais oferece rotação automática: você recebe um endpoint, e o IP muda automaticamente com uma frequência definida ou após cada solicitação. Isso simplifica a configuração do scraper.

Exemplo de configuração de um pool de proxies em Python:

import requests
import random

# Lista de proxies (pode ser carregada de um arquivo)
proxy_list = [
    'http://user:pass@proxy1.example.com:8000',
    'http://user:pass@proxy2.example.com:8000',
    'http://user:pass@proxy3.example.com:8000',
    # ... mais 50-100 proxies
]

def get_random_proxy():
    proxy = random.choice(proxy_list)
    return {
        'http': proxy,
        'https': proxy
    }

# Uso
for product_id in product_list:
    proxy = get_random_proxy()  # Proxy aleatório para cada solicitação
    response = requests.get(url, proxies=proxy)
    # Processamento...

Configuração de cabeçalhos e fingerprint para simulação de navegador

Os marketplaces analisam não apenas o IP e a frequência das solicitações, mas também os cabeçalhos HTTP. Se seu scraper envia solicitações com cabeçalhos padrão da biblioteca (por exemplo, python-requests/2.28.0), ele é imediatamente identificado como um bot.

Cabeçalhos obrigatórios para simulação de navegador:

headers = {
    '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,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',
    'Cache-Control': 'max-age=0',
    'Referer': 'https://www.google.com/'
}

Pontos importantes:

• User-Agent deve corresponder a um navegador real. Use versões atuais do Chrome, Firefox, Safari. Altere o User-Agent a cada 100-200 solicitações.
• Accept-Language deve corresponder à geografia do proxy. Se você usar IPs brasileiros — coloque pt-BR, para IPs ucranianos — uk-UA.
• Referer mostra de onde o usuário veio. Para a primeira solicitação, use Google/Yandex, para as seguintes — páginas internas do marketplace.
• Os cabeçalhos Sec-Fetch-* adicionam realismo. Navegadores modernos os enviam automaticamente.

Fingerprinting TLS: Sistemas de proteção avançados (Ozon, Wildberries) analisam os parâmetros da conexão TLS: ordem das suites de criptografia, extensões, versão do protocolo. Bibliotecas padrão em Python/Node.js têm um fingerprint diferente dos navegadores.

A solução é usar bibliotecas especializadas:

• curl-impersonate (Python) — imita o fingerprint TLS do Chrome/Firefox
• tls-client (Go, bindings em Python) — fingerprint TLS configurável
• Playwright / Puppeteer — navegadores headless com verdadeiro TLS

Para a maioria das tarefas de scraping de marketplaces, cabeçalhos HTTP corretos e proxies residenciais são suficientes. O fingerprinting TLS é crítico apenas ao trabalhar com as APIs mais protegidas.

API vs web scraping: o que é mais seguro para scraping

Os marketplaces têm duas maneiras de obter dados: API oficial e scraping de páginas HTML (web scraping). Qual escolher para um funcionamento estável?

Recomendações para escolha:

• Use a API oficial se: Você precisa de pequenos volumes de dados (até 10.000 produtos por dia), está disposto a pagar pelo acesso, e a legalidade e estabilidade são importantes.
• Use web scraping se: Precisa de grandes volumes de dados, a API oficial não fornece as informações necessárias (por exemplo, preços dos concorrentes), e o orçamento é limitado.

Abordagem híbrida: Muitos scrapers profissionais combinam ambos os métodos. Por exemplo, obtêm uma lista de produtos através da API (rápido e legal), e as informações detalhadas sobre preços e estoques são scrappeadas das páginas HTML (mais dados).

APIs internas dos marketplaces: Além da API oficial, os marketplaces usam APIs internas para o funcionamento do site. Por exemplo, o Wildberries carrega dados de produtos através de https://card.wb.ru/cards/detail. Esses endpoints não são documentados, mas funcionam mais rápido que o scraping HTML. A desvantagem — podem mudar sem aviso prévio.

Configuração de scrapers e ferramentas populares

A maioria dos vendedores e profissionais de marketing usa ferramentas prontas para scraping de marketplaces. Vamos ver como configurar corretamente proxies e limites em soluções populares.

Configuração do Scrapy (framework Python)

Scrapy é um framework popular para web scraping. Para trabalhar com marketplaces, adicione ao settings.py:

# Delays entre solicitações
DOWNLOAD_DELAY = 3  # 3 segundos
RANDOMIZE_DOWNLOAD_DELAY = True  # Randomização de 0.5*DELAY a 1.5*DELAY

# Limites de solicitações simultâneas
CONCURRENT_REQUESTS = 8
CONCURRENT_REQUESTS_PER_DOMAIN = 2

# Configuração de proxies (via middleware rotating-proxies)
ROTATING_PROXY_LIST = [
    'http://user:pass@proxy1.example.com:8000',
    'http://user:pass@proxy2.example.com:8000',
    # ... lista de proxies
]

# Rotação de User-Agent
USER_AGENT_LIST = [
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0',
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Safari/537.36',
    # ... lista de User-Agent
]

# Tentativas de repetição em caso de erros
RETRY_TIMES = 3
RETRY_HTTP_CODES = [429, 500, 502, 503, 504]

Configuração do Octoparse (scraper visual sem código)

Octoparse é uma ferramenta popular para scraping sem programação. Configuração de proxies e limites:

1. Abra Configurações da Tarefa → Opções Avançadas
2. Na seção "Rede", ative "Usar Servidor Proxy"
3. Adicione a lista de proxies no formato IP:PORT:USER:PASS
4. Ative "Rotacionar IP para cada solicitação" para rotação automática
5. Na seção "Velocidade", defina "Lento" ou "Personalizado" com delay de 3-5 segundos
6. Ative "Delay aleatório" para simular comportamento humano

Configuração do Selenium (automação de navegador)

Selenium controla um navegador real, portanto, contorna muitas proteções. Exemplo de configuração com proxy:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import time
import random

# Configuração do Chrome com proxy
chrome_options = Options()
chrome_options.add_argument('--proxy-server=http://user:pass@proxy.example.com:8000')
chrome_options.add_argument('--disable-blink-features=AutomationControlled')
chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
chrome_options.add_experimental_option('useAutomationExtension', False)

driver = webdriver.Chrome(options=chrome_options)

# Ocultando o WebDriver
driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")

# Scraping com delays
urls = ['https://www.wildberries.ru/catalog/...', ...]

for url in urls:
    driver.get(url)
    # Delay aleatório de 3-7 segundos
    time.sleep(random.uniform(3, 7))
    
    # Scroll para simular leitura
    driver.execute_script("window.scrollTo(0, document.body.scrollHeight/2);")
    time.sleep(random.uniform(1, 3))
    
    # Scraping de dados
    # ...

Serviços prontos de scraping de marketplaces

Se você não quer configurar o scraper sozinho, use serviços especializados:

• Mpstats.io — análise do Wildberries e Ozon, monitoramento automático de preços e vendas
• SellerFox — monitoramento de concorrentes em marketplaces, rastreamento de estoques
• Moneyplace — scraping do Avito, publicação automática de anúncios
• Parsehub — scraper visual para qualquer site, incluindo marketplaces

Esses serviços já configuraram proxies, limites e contorno de proteções — você só precisa indicar o que scrappear. A desvantagem — assinatura mensal a partir de 2000₽.

Monitoramento de bloqueios e reação automática

Mesmo com as configurações corretas, bloqueios são possíveis: os marketplaces atualizam a proteção, proxies entram em listas de bloqueio, limites mudam. É importante monitorar problemas e reagir automaticamente.

Sinais de bloqueio que devem ser monitorados:

• HTTP 429 (Too Many Requests) — limite de solicitações excedido, é necessário uma pausa ou troca de IP
• HTTP 403 (Forbidden) — IP bloqueado, é necessária uma rotação imediata de proxies
• HTTP 503 (Service Unavailable) — sobrecarga temporária ou proteção contra DDoS
• Captcha na resposta — automação detectada, é necessário reduzir a atividade
• Respostas vazias ou redirecionamento para a página inicial — bloqueio suave
• Aumento repentino no tempo de resposta — pode haver limitação de taxa do lado do servidor

Reação automática a bloqueios (exemplo em Python):

import requests
import time
from datetime import datetime

class SmartParser:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
        self.current_proxy_index = 0
        self.request_count = 0
        self.blocked_proxies = set()
        
    def get_next_proxy(self):
        # Ignorar proxies bloqueados
        while self.current_proxy_index in self.blocked_proxies:
            self.current_proxy_index = (self.current_proxy_index + 1) % len(self.proxy_list)
        
        proxy = self.proxy_list[self.current_proxy_index]
        return {'http': proxy, 'https': proxy}
    
    def rotate_proxy(self):
        self.current_proxy_index = (self.current_proxy_index + 1) % len(self.proxy_list)
        self.request_count = 0
        
    def make_request(self, url):
        max_retries = 3
        
        for attempt in range(max_retries):
            try:
                proxy = self.get_next_proxy()
                response = requests.get(url, proxies=proxy, timeout=10)
                
                # Verificação de bloqueio
                if response.status_code == 429:
                    print(f"[{datetime.now()}] Limite de taxa! Pausa de 60 segundos...")
                    time.sleep(60)
                    self.rotate_proxy()
                    continue
                    
                elif response.status_code == 403:
                    print(f"[{datetime.now()}] IP bloqueado! Rotação de proxies...")
                    self.blocked_proxies.add(self.current_proxy_index)
                    self.rotate_proxy()
                    continue
                    
                elif response.status_code == 503:
                    print(f"[{datetime.now()}] Servidor sobrecarregado. Pausa de 120 segundos...")
                    time.sleep(120)
                    continue
                
                # Solicitação bem-sucedida
                self.request_count += 1
                
                # Rotação após 200 solicitações
                if self.request_count >= 200:
                    self.rotate_proxy()
                    time.sleep(10)  # Pausa após rotação
                
                return response
                
            except requests.exceptions.Timeout:
                print(f"[{datetime.now()}] Timeout. Tentativa {attempt + 1}/{max_retries}")
                time.sleep(5)
                
        return None  # Todas as tentativas esgotadas

Registro e alertas: Configure notificações para eventos críticos. Por exemplo, envie uma mensagem no Telegram quando:

• Mais de 30% dos proxies do pool foram bloqueados
• A porcentagem de solicitações bem-sucedidas caiu abaixo de 80%
• O scraper não obteve dados por mais de 30 minutos
• Captcha detectada nas respostas

Métricas para monitoramento:

Use dashboards para visualizar métricas: Grafana, Datadog ou planilhas simples do Google com atualização automática via API.

Conclusão

Bloqueios ao fazer scraping de marketplaces não são um obstáculo, mas uma tarefa que pode ser resolvida com a configuração correta das ferramentas. Pontos-chave para um funcionamento estável sem bans:

• Use proxies residenciais para Wildberries, Ozon e Avito — proxies de data centers não funcionam aqui
• Configure delays randomizados de 2-5 segundos entre as solicitações
• Rotacione IP após cada 150-300 solicitações ou a cada 30-60 minutos
• Use cabeçalhos HTTP realistas com User-Agent atualizados
• Monitore bloqueios e reaja automaticamente a eles
• Para Avito, a vinculação geográfica do IP à cidade do anúncio é obrigatória

Um scraper bem configurado com proxies de qualidade pode operar por meses sem um único bloqueio, coletando dezenas de milhares de produtos diariamente. O principal — não correr atrás da velocidade, mas simular o comportamento de um usuário comum.

Se você planeja fazer scraping regularmente do Wildberries, Ozon ou Avito, recomendamos o uso de proxies residenciais com rotação automática — eles garantem máxima estabilidade e mínimo risco de bloqueios. Para tarefas que exigem IPs móveis (por exemplo, contornar bloqueios rigorosos do Avito), proxies móveis com IPs de operadoras russas são adequados.