Rotação de IPs: Como e Por Que Mudar Seus Proxies

Solicitação 1 → Proxy A (185.45.12.34) → O site vê 185.45.12.34
Solicitação 2 → Proxy B (92.118.45.78) → O site vê 92.118.45.78
Solicitação 3 → Proxy C (178.62.91.22) → O site vê 178.62.91.22
Solicitação 4 → Proxy A (185.45.12.34) → O site vê 185.45.12.34

1. Contornar o Rate Limiting (limites de solicitação)

A maioria dos sites limita o número de solicitações de um único IP por unidade de tempo. Por exemplo, uma API pode permitir apenas 100 solicitações por hora por IP. Usando uma rotação de 10 IPs, você pode enviar 1.000 solicitações por hora, distribuindo a carga.

2. Evitar banimentos de IP ao fazer scraping

Ao coletar grandes volumes de dados (scraping de e-commerce, monitoramento de preços, coleta de contatos), solicitações frequentes de um único IP levam rapidamente ao bloqueio. A rotação permite distribuir as solicitações para que cada IP faça apenas algumas solicitações por hora — como um usuário normal.

3. Contornar bloqueios geográficos

Muitos serviços exibem conteúdo ou preços diferentes dependendo da geolocalização. A rotação de proxies de diferentes países permite coletar dados de todas as regiões sem a necessidade de estar fisicamente lá.

4. Mascarar a automação

Sistemas de proteção (Cloudflare, Akamai, PerimeterX) analisam padrões comportamentais. Se centenas de solicitações vierem de um único IP em um curto período, é um sinal claro de bot. A rotação ajuda a criar a ilusão de múltiplos usuários independentes.

5. Inteligência competitiva

O rastreamento de preços de concorrentes, monitoramento de campanhas publicitárias, análise de posições de SEO exigem verificações frequentes. A rotação de IP permite coletar esses dados discretamente, sem atrair a atenção dos concorrentes.

6. Teste e monitoramento

Verificar a disponibilidade do site de diferentes regiões, testar experimentos A/B, monitorar posições de SEO em diferentes países — tudo isso requer o uso de endereços IP de diferentes localizações.

1. Rate Limiting (análise da frequência de solicitações)

Os sites monitoram o número de solicitações de um IP específico em um determinado período. Limites típicos:

• Sites conservadores: 10-30 solicitações por minuto
• Sites médios: 50-100 solicitações por minuto
• Serviços de API: 100-1000 solicitações por hora (frequentemente especificado na documentação)

2. Análise de Reputação de IP

Existem bancos de dados extensos que classificam endereços IP por tipo:

• IP Residencial — provedores de internet doméstica (alta reputação)
• IP de Data Center — servidores de empresas de hospedagem (suspeitos)
• IP Móvel — operadoras de celular (alta reputação)
• IP de Proxy Conhecido — servidores proxy conhecidos (frequentemente bloqueados)

3. Impressão Digital do Navegador (Browser Fingerprinting)

Mesmo com a troca de IP, os sistemas de proteção podem correlacionar solicitações pela "impressão digital" única do navegador: resolução de tela, fontes instaladas, plugins, impressão digital WebGL, impressão digital Canvas, impressão digital de Áudio.

4. Análise Comportamental

Sistemas anti-bot modernos analisam o comportamento:

• Velocidade de rolagem da página
• Movimentos do mouse
• Padrões de clique
• Tempo entre ações
• Sequência de visitação de páginas

5. Impressão Digital TLS

Durante a conexão HTTPS, o servidor pode determinar a versão TLS, as suítes de criptografia usadas, as extensões — esses dados formam uma impressão digital única que pode ser usada para rastreamento mesmo com a troca de IP.

Intervalos de rotação típicos:

• A cada 5 minutos — para scraping intensivo com alta frequência de solicitações
• A cada 10-15 minutos — modo padrão para a maioria das tarefas
• A cada 30-60 minutos — para tarefas com baixa frequência de solicitações
• A cada 2-24 horas — para sessões persistentes (sticky sessions)

✅ Vantagens:

• Previsibilidade — você sabe exatamente quando a troca de IP ocorrerá
• Simplicidade de implementação — fácil de configurar com temporizadores
• Adequado para sticky sessions — a sessão pode ser mantida por um tempo específico
• Distribuição uniforme — a carga é distribuída uniformemente ao longo do tempo
• Fácil de escalar — várias sessões podem ser executadas em paralelo com temporizadores diferentes

❌ Desvantagens:

• Ineficiência com carga variável — se houver poucas solicitações, o IP muda desnecessariamente
• Risco de exceder limites — se muitas solicitações forem enviadas em um curto intervalo
• Padrão previsível — sistemas de proteção avançados podem detectar a regularidade
• Perda de sessão — a troca de IP pode resultar na perda de autorização ou contexto

🎯 Melhor adequado para:

• Tarefas com carga previsível
• Sessões de longa duração (autorização, trabalho com contas)
• Monitoramento com intervalos fixos
• Situações onde a estabilidade do IP por um certo tempo é importante

10:00 - Proxy A → Verificação de preços (50 produtos)
10:30 - Proxy B → Verificação de preços (50 produtos)
11:00 - Proxy C → Verificação de preços (50 produtos)
11:30 - Proxy D → Verificação de preços (50 produtos)
12:00 - Proxy A → Verificação de preços (50 produtos)

Opções de implementação:

1. Rotação por solicitação — novo IP para cada solicitação (estratégia mais agressiva)
2. Rotação em lote (Burst rotation) — troca de IP após N solicitações (por exemplo, a cada 10 solicitações)
3. Rotação adaptativa — troca de IP ao receber códigos HTTP específicos (429, 403, 503)
4. Baseada em sessão — troca de IP ao iniciar uma nova sessão lógica

✅ Vantagens:

• Máxima proteção contra rate limiting — cada IP faz um número mínimo de solicitações
• Adaptabilidade — a rotação ocorre apenas quando necessário
• Uso eficiente do pool — os IPs mudam apenas quando necessário
• Reação rápida a bloqueios — pode-se trocar o IP instantaneamente em caso de erro
• Ideal para scraping — cada página é solicitada com um novo IP

❌ Desvantagens:

• Impossibilidade de manter a sessão — a troca constante de IP quebra a autorização
• Mais difícil de depurar — é mais difícil reproduzir um problema com um IP específico
• Esgotamento rápido do pool — em trabalho intensivo, todos os IPs podem ser usados rapidamente
• Mais caro — requer um pool maior de proxies para um trabalho eficaz
• Sobrecarga na troca — cada troca de IP leva frações de segundo

🎯 Melhor adequado para:

• Scraping intensivo de grandes volumes de dados
• Contornar limites de taxa rígidos
• Solicitações únicas sem necessidade de manter o estado
• Scraping de páginas públicas sem autenticação
• Tarefas onde cada solicitação é independente da anterior

Tipo de site	Quantidade recomendada de solicitações	Intervalo
Sites altamente protegidos	1-3 solicitações	5-10 seg entre solicitações
E-commerce (Marketplaces)	5-10 solicitações	2-5 seg entre solicitações
Portais de notícias	10-20 solicitações	1-3 seg entre solicitações
APIs Públicas	Depende dos limites	De acordo com a documentação
Sites estáticos	20-50 solicitações	0.5-2 seg entre solicitações

Opções de rotação aleatória:

• Intervalos de tempo aleatórios — troca de IP após intervalos aleatórios (por exemplo, de 3 a 15 minutos)
• Contagem aleatória de solicitações — troca após um número aleatório de solicitações (por exemplo, de 5 a 20)
• Seleção aleatória de IP — a seleção do próximo IP do pool é feita aleatoriamente, não sequencialmente
• Rotação ponderada — IPs com melhor reputação são usados com mais frequência
• Rotação com Jitter — adição de um atraso aleatório a intervalos fixos

✅ Vantagens:

• Imprevisibilidade — é mais difícil para os sistemas de proteção detectarem um padrão
• Imitação de usuários reais — as pessoas não agem com regularidade perfeita
• Flexibilidade — pode ser combinado com outras estratégias
• Padrão de tráfego natural — mais semelhante ao tráfego orgânico
• Mais difícil de detectar — mesmo ao analisar grandes volumes de dados

❌ Desvantagens:

• Mais difícil de prever — é difícil estimar a velocidade de conclusão da tarefa
• Pode ser ineficiente — com uma aleatoriedade desfavorável, o IP pode mudar com muita frequência
• Complica a depuração — é mais difícil reproduzir um problema devido à aleatoriedade
• Requer um pool maior — para garantir uma carga uniforme
• Mais difícil de implementar — requer um bom algoritmo de geração de aleatoriedade

🎯 Melhor adequado para:

• Contornar sistemas de proteção avançados (Cloudflare, Akamai)
• Projetos de longo prazo com altos requisitos de discrição
• Inteligência competitiva
• Scraping de sites com análise comportamental
• Tarefas onde a máxima imitação do comportamento humano é importante

Critério	Baseada em Tempo	Baseada em Solicitação	Aleatória
Complexidade de implementação	⭐ Fácil	⭐⭐ Média	⭐⭐⭐ Difícil
Previsibilidade	✅ Alta	⚠️ Média	❌ Baixa
Proteção contra rate limit	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Discrição	⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐
Suporte a sessões	✅ Sim	❌ Não	⚠️ Parcialmente
Eficiência do uso do pool	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Velocidade de scraping	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Tamanho do pool necessário	Pequeno-Médio	Grande	Médio-Grande
Facilidade de depuração	✅ Fácil	⚠️ Médio	❌ Difícil
Custo	💰 Baixo	💰💰💰 Alto	💰💰 Médio

1. Gerenciamento de redes sociais

Ao trabalhar com múltiplas contas do Instagram, Facebook, Twitter, é necessário manter o mesmo IP durante toda a sessão. A troca frequente de IP em uma conta logada é um caminho direto para o bloqueio.

Recomendação: Sticky session de 1-2 horas, um IP exclusivo para cada conta.

2. E-commerce e carrinhos de compra

Adicionar itens ao carrinho, finalizar a compra, checkout — todos esses processos exigem a manutenção da sessão. A troca de IP resultará na perda do carrinho e na necessidade de recomeçar.

Recomendação: Sticky session de 30-60 minutos para o ciclo completo de compra.

3. Preenchimento de formulários e registro

Formulários multi-etapas, registro em sites, verificação de e-mail — todos esses processos exigem consistência de IP. A troca de IP entre etapas pode levantar suspeitas ou causar erros de validação.

Recomendação: Sticky session de 10-30 minutos para concluir o processo.

4. Teste de aplicações web

Testes E2E, automação com Selenium/Puppeteer, verificação de cenários de usuário — tudo isso requer a manutenção do IP para imitar a experiência de um usuário real.

Recomendação: Sticky session pela duração total do teste (5-60 minutos).

5. Trabalho com APIs que exigem autenticação

Muitas APIs emitem um token de acesso vinculado ao endereço IP. A troca de IP invalidará o token e exigirá nova autenticação.

Recomendação: Sticky session pela duração do token (geralmente 1-24 horas).

import requests
from itertools import cycle

# Lista de proxies
proxies_list = [
    'http://user:pass@185.45.12.34:8000',
    'http://user:pass@92.118.45.78:8000',
    'http://user:pass@178.62.91.22:8000',
    'http://user:pass@45.89.234.56:8000'
]

# Cria um iterador infinito
proxy_pool = cycle(proxies_list)

# Função para enviar uma solicitação
def make_request(url):
    proxy = next(proxy_pool)
    proxies = {
        'http': proxy,
        'https': proxy
    }

    try:
        response = requests.get(url, proxies=proxies, timeout=10)
        print(f"Sucesso com {proxy}: {response.status_code}")
        return response
    except Exception as e:
        print(f"Erro com {proxy}: {e}")
        return None

# Uso
urls = ['https://example.com/page1', 'https://example.com/page2']
for url in urls:
    make_request(url)
    # Cada solicitação usa o próximo proxy da lista

import requests
import random
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class ProxyRotator:
    def __init__(self, proxies_list):
        self.proxies = proxies_list
        self.failed_proxies = set()

    def get_random_proxy(self):
        """Obter um proxy funcional aleatório"""
        available = [p for p in self.proxies if p not in self.failed_proxies]
        if not available:
            # Se todos os proxies falharem, redefinir a lista
            self.failed_proxies.clear()
            available = self.proxies
        return random.choice(available)

    def make_request(self, url, max_retries=3):
        """Enviar solicitação com rotação automática em caso de erros"""
        session = requests.Session()

        # Configuração da estratégia de repetição (retry)
        retry = Retry(
            total=max_retries,
            backoff_factor=0.5,
            status_forcelist=[500, 502, 503, 504]
        )
        adapter = HTTPAdapter(max_retries=retry)
        session.mount('http://', adapter)
        session.mount('https://', adapter)

        for attempt in range(max_retries):
            proxy = self.get_random_proxy()
            proxies = {'http': proxy, 'https': proxy}

            try:
                response = session.get(url, proxies=proxies, timeout=15)

                # Verificação de rate limiting
                if response.status_code == 429:
                    print(f"Limite de taxa atingido em {proxy}, rotacionando...")
                    self.failed_proxies.add(proxy)
                    continue

                print(f"✓ Sucesso com {proxy}")
                return response

            except Exception as e:
                print(f"✗ Falha com {proxy}: {e}")
                self.failed_proxies.add(proxy)

        raise Exception(f"Todas as tentativas falharam para {url}")

# Uso
proxies = [
    'http://user:pass@proxy1.com:8000',
    'http://user:pass@proxy2.com:8000',
    'http://user:pass@proxy3.com:8000'
]

rotator = ProxyRotator(proxies)
response = rotator.make_request('https://example.com')

import requests
import time
from datetime import datetime, timedelta

class TimeBasedRotator:
    def __init__(self, proxies_list, rotation_interval=600):
        """
        rotation_interval: tempo em segundos (600 = 10 minutos)
        """
        self.proxies = proxies_list
        self.rotation_interval = rotation_interval
        self.current_proxy = None
        self.last_rotation = None
        self.current_index = 0

    def get_proxy(self):
        """Obter o proxy atual ou rotacionar se o tempo tiver expirado"""
        now = datetime.now()

        # Primeira execução ou tempo expirado
        if (self.last_rotation is None or
            (now - self.last_rotation).seconds >= self.rotation_interval):

            self.current_proxy = self.proxies[self.current_index]
            self.current_index = (self.current_index + 1) % len(self.proxies)
            self.last_rotation = now
            print(f"🔄 Rotacionado para: {self.current_proxy}")

        return self.current_proxy

    def make_request(self, url):
        proxy = self.get_proxy()
        proxies = {'http': proxy, 'https': proxy}

        response = requests.get(url, proxies=proxies, timeout=10)
        return response

# Uso: O IP mudará a cada 10 minutos
rotator = TimeBasedRotator(proxies_list, rotation_interval=600)

for i in range(100):
    response = rotator.make_request('https://example.com')
    print(f"Solicitação {i}: {response.status_code}")
    time.sleep(2)  # 2 segundos entre as solicitações

const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

class ProxyRotator {
  constructor(proxies) {
    this.proxies = proxies;
    this.currentIndex = 0;
  }

  getNextProxy() {
    const proxy = this.proxies[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxies.length;
    return proxy;
  }

  async makeRequest(url, options = {}) {
    const proxy = this.getNextProxy();
    const agent = new HttpsProxyAgent(proxy);

    try {
      const response = await axios.get(url, {
        ...options,
        httpAgent: agent,
        httpsAgent: agent,
        timeout: 10000
      });

      console.log(`✓ Sucesso com ${proxy}: ${response.status}`);
      return response.data;

    } catch (error) {
      console.error(`✗ Falha com ${proxy}: ${error.message}`);
      throw error;
    }
  }
}

// Uso
const proxies = [
  'http://user:pass@proxy1.com:8000',
  'http://user:pass@proxy2.com:8000',
  'http://user:pass@proxy3.com:8000'
];

const rotator = new ProxyRotator(proxies);

async function scrape() {
  const urls = [
    'https://example.com/page1',
    'https://example.com/page2',
    'https://example.com/page3'
  ];

  for (const url of urls) {
    try {
      await rotator.makeRequest(url);
    } catch (error) {
      console.error(`Falha ao raspar ${url}`);
    }
  }
}

scrape();

const puppeteer = require('puppeteer');

class PuppeteerProxyRotator {
  constructor(proxies) {
    this.proxies = proxies;
    this.currentIndex = 0;
  }

  getNextProxy() {
    const proxy = this.proxies[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxies.length;
    return proxy;
  }

  async scrapeWithRotation(url) {
    const proxy = this.getNextProxy();

    // Parsing do URL do proxy
    const proxyUrl = new URL(proxy);

    const browser = await puppeteer.launch({
      headless: true,
      args: [
        `--proxy-server=${proxyUrl.protocol}//${proxyUrl.host}`,
        '--no-sandbox',
        '--disable-setuid-sandbox'
      ]
    });

    try {
      const page = await browser.newPage();

      // Autenticação do proxy se houver
      if (proxyUrl.username && proxyUrl.password) {
        await page.authenticate({
          username: proxyUrl.username,
          password: proxyUrl.password
        });
      }

      await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });

      const content = await page.content();
      console.log(`✓ Raspado ${url} com ${proxy}`);

      await browser.close();
      return content;

    } catch (error) {
      console.error(`✗ Erro com ${proxy}: ${error.message}`);
      await browser.close();
      throw error;
    }
  }
}

// Uso
const proxies = [
  'http://user:pass@185.45.12.34:8000',
  'http://user:pass@92.118.45.78:8000'
];

const rotator = new PuppeteerProxyRotator(proxies);

async function scrapeMultiplePages() {
  const urls = ['https://example.com/1', 'https://example.com/2'];

  for (const url of urls) {
    await rotator.scrapeWithRotation(url);
    // Cada página é aberta com um novo proxy
  }
}

scrapeMultiplePages();

Como funciona:

1. Você se conecta a um endpoint (por exemplo, rotate.proxycove.com:8000)
2. A cada solicitação, o gateway seleciona automaticamente um IP aleatório do pool
3. Você não precisa gerenciar a lista de proxies nem escrever a lógica de rotação
4. Sessões persistentes podem ser configuradas através de parâmetros (session_id no nome de usuário)

# Exemplo Python com rotating gateway
import requests

# Para rotação: cada solicitação = novo IP
proxies = {
    'http': 'http://username:password@rotate.proxycove.com:8000',
    'https': 'http://username:password@rotate.proxycove.com:8000'
}

# Para sticky session: adicionamos session_id
sticky_proxies = {
    'http': 'http://username-session-abc123:password@rotate.proxycove.com:8000',
    'https': 'http://username-session-abc123:password@rotate.proxycove.com:8000'
}

# Rotação: cada solicitação com um novo IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=proxies)
    print(f"Solicitação {i}: IP = {r.text}")  # IP diferente a cada vez

# Sticky: todas as solicitações com o mesmo IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=sticky_proxies)
    print(f"Solicitação {i}: IP = {r.text}")  # Sempre o mesmo IP

1. ProxyBroker

Biblioteca para encontrar, verificar e usar proxies com rotação automática.

2. rotating-proxies (Scrapy middleware)

Middleware para Scrapy com suporte a rotação automática e gerenciamento de blacklist.

3. requests-ip-rotator

Extensão para a biblioteca requests com suporte a AWS API Gateway para rotação de IP.

1. proxy-chain

Biblioteca para criar um servidor proxy HTTP com rotação e tunneling.

2. puppeteer-extra-plugin-proxy-rotation

Plugin para Puppeteer com rotação automática de proxy para cada página.

1. Rotação Ponderada (Weighted Rotation)

Proxies com melhor reputação e velocidade são usados com mais frequência. Por exemplo, IPs residenciais recebem peso 0.6 e IPs de datacenter, peso 0.4.

2. Rotação com Segmentação Geográfica (Geo-targeted Rotation)

Seleção automática de proxy da região/país desejado dependendo do URL de destino. Por exemplo, para um domínio .de, são usados proxies alemães.

3. Verificação de Saúde e Remoção Automática (Health Check & Auto-removal)

Verificação periódica da saúde dos proxies e exclusão automática dos que não funcionam do pool. Restauração após um período de "cooldown".

4. Rotação Adaptativa à Taxa de Solicitação (Request Rate Adaptive Rotation)

A frequência de rotação se adapta automaticamente com base nos códigos HTTP recebidos. Em caso de 429 (Too Many Requests), a rotação é acelerada.

Configurações típicas de sticky sessions:

• 1-5 minutos — sessões curtas para operações rápidas
• 10-30 minutos — modo padrão para a maioria das tarefas
• 1-2 horas — para trabalho com contas e autorização
• 12-24 horas — duração máxima para operações de longo prazo
• Infinito (até desconexão) — o IP é mantido até o fim da sessão

✅ Vantagens das Sticky Sessions:

• Manutenção da autorização — você pode fazer login em uma conta e operar em nome dela
• Suporte a cookies — o site "lembra" de você entre as solicitações
• Comportamento natural — um usuário normal usa um IP por sessão
• Menos CAPTCHA — um IP constante levanta menos suspeitas
• Consistência de ações — pode-se realizar operações multi-etapas
• Mais fácil de depurar — mais fácil reproduzir um problema com um IP específico

❌ Desvantagens das Sticky Sessions:

• Vulnerabilidade ao rate limiting — todas as solicitações vêm do mesmo IP
• Risco de banimento de sessão inteira — se o IP for bloqueado, você perde todo o progresso
• Menor escalabilidade — limitado pela velocidade de um único IP
• Duração finita — a sessão acabará inevitavelmente e o IP mudará

✅ Vantagens dos Proxies Rotativos:

• Máxima proteção contra rate limiting — cada IP faz um número mínimo de solicitações
• Alta velocidade de scraping — pode-se enviar milhares de solicitações paralelas
• Risco mínimo de bloqueio — mesmo que um IP seja bloqueado, isso não afetará o trabalho
• Escalabilidade — fácil aumentar o volume de trabalho
• Discrição — parece vir de múltiplos usuários independentes

❌ Desvantagens dos Proxies Rotativos:

• Impossibilidade de autorização — a troca constante de IP quebra a sessão
• Cookies não funcionam — cada solicitação parece vir de um novo usuário
• Operações multi-etapas não funcionam — carrinho, formulários, checkout não funcionam
• Mais CAPTCHA — a troca frequente de IP pode levantar suspeitas
• Mais caro — requer um grande pool de proxies

Critério	Sticky Sessions	Proxies Rotativos
Autorização	✅ Sim	❌ Não
Cookies	✅ Funcionam	❌ Não funcionam
Contorno de Rate Limit	⚠️ Limitado	✅ Excelente
Velocidade de scraping	⭐⭐⭐	⭐⭐⭐⭐⭐
Risco de bloqueio	⚠️ Médio	✅ Baixo
Custo	💰 Inferior	💰💰💰 Superior
Complexidade	⭐ Simples	⭐⭐ Médio

1. Gerenciamento de redes sociais

Ao trabalhar com múltiplas contas do Instagram, Facebook, Twitter, é necessário manter o mesmo IP durante toda a sessão. A troca frequente de IP em uma conta logada é um caminho direto para o bloqueio.

Recomendação: Sticky session de 1-2 horas, um IP exclusivo para cada conta.

2. E-commerce e carrinhos de compra

Adicionar itens ao carrinho, finalizar a compra, checkout — todos esses processos exigem a manutenção da sessão. A troca de IP resultará na perda do carrinho e na necessidade de recomeçar.

Recomendação: Sticky session de 30-60 minutos para o ciclo completo de compra.

3. Preenchimento de formulários e registro

Formulários multi-etapas, registro em sites, verificação de e-mail — todos esses processos exigem consistência de IP. A troca de IP entre etapas pode levantar suspeitas ou causar erros de validação.

Recomendação: Sticky session de 10-30 minutos para concluir o processo.

4. Teste de aplicações web

Testes E2E, automação com Selenium/Puppeteer, verificação de cenários de usuário — tudo isso requer a manutenção do IP para imitar a experiência de um usuário real.

Recomendação: Sticky session pela duração total do teste (5-60 minutos).

5. Trabalho com APIs que exigem autenticação

Muitas APIs emitem um token de acesso vinculado ao endereço IP. A troca de IP invalidará o token e exigirá nova autenticação.

Recomendação: Sticky session pela duração do token (geralmente 1-24 horas).

import requests
from itertools import cycle

# Lista de proxies
proxies_list = [
    'http://user:pass@185.45.12.34:8000',
    'http://user:pass@92.118.45.78:8000',
    'http://user:pass@178.62.91.22:8000',
    'http://user:pass@45.89.234.56:8000'
]

# Cria um iterador infinito
proxy_pool = cycle(proxies_list)

# Função para enviar uma solicitação
def make_request(url):
    proxy = next(proxy_pool)
    proxies = {
        'http': proxy,
        'https': proxy
    }

    try:
        response = requests.get(url, proxies=proxies, timeout=10)
        print(f"Sucesso com {proxy}: {response.status_code}")
        return response
    except Exception as e:
        print(f"Erro com {proxy}: {e}")
        return None

# Uso
urls = ['https://example.com/page1', 'https://example.com/page2']
for url in urls:
    make_request(url)
    # Cada solicitação usa o próximo proxy da lista

import requests
import random
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class ProxyRotator:
    def __init__(self, proxies_list):
        self.proxies = proxies_list
        self.failed_proxies = set()

    def get_random_proxy(self):
        """Obter um proxy funcional aleatório"""
        available = [p for p in self.proxies if p not in self.failed_proxies]
        if not available:
            # Se todos os proxies falharem, redefinir a lista
            self.failed_proxies.clear()
            available = self.proxies
        return random.choice(available)

    def make_request(self, url, max_retries=3):
        """Enviar solicitação com rotação automática em caso de erros"""
        session = requests.Session()

        # Configuração da estratégia de repetição (retry)
        retry = Retry(
            total=max_retries,
            backoff_factor=0.5,
            status_forcelist=[500, 502, 503, 504]
        )
        adapter = HTTPAdapter(max_retries=retry)
        session.mount('http://', adapter)
        session.mount('https://', adapter)

        for attempt in range(max_retries):
            proxy = self.get_random_proxy()
            proxies = {'http': proxy, 'https': proxy}

            try:
                response = session.get(url, proxies=proxies, timeout=15)

                # Verificação de rate limiting
                if response.status_code == 429:
                    print(f"Limite de taxa atingido em {proxy}, rotacionando...")
                    self.failed_proxies.add(proxy)
                    continue

                print(f"✓ Sucesso com {proxy}")
                return response

            except Exception as e:
                print(f"✗ Falha com {proxy}: {e}")
                self.failed_proxies.add(proxy)

        raise Exception(f"Todas as tentativas falharam para {url}")

# Uso
proxies = [
    'http://user:pass@proxy1.com:8000',
    'http://user:pass@proxy2.com:8000',
    'http://user:pass@proxy3.com:8000'
]

rotator = ProxyRotator(proxies)
response = rotator.make_request('https://example.com')

import requests
import time
from datetime import datetime, timedelta

class TimeBasedRotator:
    def __init__(self, proxies_list, rotation_interval=600):
        """
        rotation_interval: tempo em segundos (600 = 10 minutos)
        """
        self.proxies = proxies_list
        self.rotation_interval = rotation_interval
        self.current_proxy = None
        self.last_rotation = None
        self.current_index = 0

    def get_proxy(self):
        """Obter o proxy atual ou rotacionar se o tempo tiver expirado"""
        now = datetime.now()

        # Primeira execução ou tempo expirado
        if (self.last_rotation is None or
            (now - self.last_rotation).seconds >= self.rotation_interval):

            self.current_proxy = self.proxies[self.current_index]
            self.current_index = (self.current_index + 1) % len(self.proxies)
            self.last_rotation = now
            print(f"🔄 Rotacionado para: {self.current_proxy}")

        return self.current_proxy

    def make_request(self, url):
        proxy = self.get_proxy()
        proxies = {'http': proxy, 'https': proxy}

        response = requests.get(url, proxies=proxies, timeout=10)
        return response

# Uso: O IP mudará a cada 10 minutos
rotator = TimeBasedRotator(proxies_list, rotation_interval=600)

for i in range(100):
    response = rotator.make_request('https://example.com')
    print(f"Solicitação {i}: {response.status_code}")
    time.sleep(2)  # 2 segundos entre as solicitações

const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

class ProxyRotator {
  constructor(proxies) {
    this.proxies = proxies;
    this.currentIndex = 0;
  }

  getNextProxy() {
    const proxy = this.proxies[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxies.length;
    return proxy;
  }

  async makeRequest(url, options = {}) {
    const proxy = this.getNextProxy();
    const agent = new HttpsProxyAgent(proxy);

    try {
      const response = await axios.get(url, {
        ...options,
        httpAgent: agent,
        httpsAgent: agent,
        timeout: 10000
      });

      console.log(`✓ Sucesso com ${proxy}: ${response.status}`);
      return response.data;

    } catch (error) {
      console.error(`✗ Falha com ${proxy}: ${error.message}`);
      throw error;
    }
  }
}

// Uso
const proxies = [
  'http://user:pass@proxy1.com:8000',
  'http://user:pass@proxy2.com:8000',
  'http://user:pass@proxy3.com:8000'
];

const rotator = new ProxyRotator(proxies);

async function scrape() {
  const urls = [
    'https://example.com/page1',
    'https://example.com/page2',
    'https://example.com/page3'
  ];

  for (const url of urls) {
    try {
      await rotator.makeRequest(url);
    } catch (error) {
      console.error(`Falha ao raspar ${url}`);
    }
  }
}

scrape();

const puppeteer = require('puppeteer');

class PuppeteerProxyRotator {
  constructor(proxies) {
    this.proxies = proxies;
    this.currentIndex = 0;
  }

  getNextProxy() {
    const proxy = this.proxies[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxies.length;
    return proxy;
  }

  async scrapeWithRotation(url) {
    const proxy = this.getNextProxy();

    // Parsing do URL do proxy
    const proxyUrl = new URL(proxy);

    const browser = await puppeteer.launch({
      headless: true,
      args: [
        `--proxy-server=${proxyUrl.protocol}//${proxyUrl.host}`,
        '--no-sandbox',
        '--disable-setuid-sandbox'
      ]
    });

    try {
      const page = await browser.newPage();

      // Autenticação do proxy se houver
      if (proxyUrl.username && proxyUrl.password) {
        await page.authenticate({
          username: proxyUrl.username,
          password: proxyUrl.password
        });
      }

      await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });

      const content = await page.content();
      console.log(`✓ Raspado ${url} com ${proxy}`);

      await browser.close();
      return content;

    } catch (error) {
      console.error(`✗ Erro com ${proxy}: ${error.message}`);
      await browser.close();
      throw error;
    }
  }
}

// Uso
const proxies = [
  'http://user:pass@185.45.12.34:8000',
  'http://user:pass@92.118.45.78:8000'
];

const rotator = new PuppeteerProxyRotator(proxies);

async function scrapeMultiplePages() {
  const urls = ['https://example.com/1', 'https://example.com/2'];

  for (const url of urls) {
    await rotator.scrapeWithRotation(url);
    // Cada página é aberta com um novo proxy
  }
}

scrapeMultiplePages();

Como funciona:

1. Você se conecta a um endpoint (por exemplo, rotate.proxycove.com:8000)
2. A cada solicitação, o gateway seleciona automaticamente um IP aleatório do pool
3. Você não precisa gerenciar a lista de proxies nem escrever a lógica de rotação
4. Sessões persistentes podem ser configuradas através de parâmetros (session_id no nome de usuário)

# Exemplo Python com rotating gateway
import requests

# Para rotação: cada solicitação = novo IP
proxies = {
    'http': 'http://username:password@rotate.proxycove.com:8000',
    'https': 'http://username:password@rotate.proxycove.com:8000'
}

# Para sticky session: adicionamos session_id
sticky_proxies = {
    'http': 'http://username-session-abc123:password@rotate.proxycove.com:8000',
    'https': 'http://username-session-abc123:password@rotate.proxycove.com:8000'
}

# Rotação: cada solicitação com um novo IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=proxies)
    print(f"Solicitação {i}: IP = {r.text}")  # IP diferente a cada vez

# Sticky: todas as solicitações com o mesmo IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=sticky_proxies)
    print(f"Solicitação {i}: IP = {r.text}")  # Sempre o mesmo IP

1. ProxyBroker

Biblioteca para encontrar, verificar e usar proxies com rotação automática.

2. rotating-proxies (Scrapy middleware)

Middleware para Scrapy com suporte a rotação automática e gerenciamento de blacklist.

3. requests-ip-rotator

Extensão para a biblioteca requests com suporte a AWS API Gateway para rotação de IP.

1. proxy-chain

Biblioteca para criar um servidor proxy HTTP com rotação e tunneling.

2. puppeteer-extra-plugin-proxy-rotation

Plugin para Puppeteer com rotação automática de proxy para cada página.

1. Rotação Ponderada (Weighted Rotation)

Proxies com melhor reputação e velocidade são usados com mais frequência. Por exemplo, IPs residenciais recebem peso 0.6 e IPs de datacenter, peso 0.4.

2. Rotação com Segmentação Geográfica (Geo-targeted Rotation)

Seleção automática de proxy da região/país desejado dependendo do URL de destino. Por exemplo, para um domínio .de, são usados proxies alemães.

3. Verificação de Saúde e Remoção Automática (Health Check & Auto-removal)

Verificação periódica da saúde dos proxies e exclusão automática dos que não funcionam do pool. Restauração após um período de "cooldown".

4. Rotação Adaptativa à Taxa de Solicitação (Request Rate Adaptive Rotation)

A frequência de rotação se adapta automaticamente com base nos códigos HTTP recebidos. Em caso de 429 (Too Many Requests), a rotação é acelerada.

1. Tipo de site de destino

• Sites altamente protegidos (bancos, redes sociais): Rotação a cada 3-5 solicitações ou a cada 10-15 minutos
• E-commerce (Amazon, Walmart): Rotação a cada 5-10 solicitações ou a cada 5-10 minutos
• Portais de notícias: Rotação a cada 10-20 solicitações ou a cada 15-30 minutos
• APIs Públicas: De acordo com a documentação (frequentemente 100-1000 req/hora por IP)
• Sites estáticos: Rotação a cada 20-50 solicitações ou a cada 30-60 minutos

2. Volume de dados a serem coletados

• Pequeno volume (até 1.000 páginas): Rotação baseada em tempo, a cada 15-30 minutos
• Volume médio (1.000-10.000 páginas): Rotação baseada em solicitação, a cada 10-15 solicitações
• Grande volume (10.000+ páginas): Rotação por solicitação com um grande pool de proxies

3. Tamanho do pool de proxies

• Pool pequeno (10-50 IPs): Rotação baseada em tempo de 30-60 minutos para permitir que cada IP "esfrie"
• Pool médio (50-200 IPs): Rotação baseada em solicitação a cada 10-20 solicitações
• Pool grande (200+ IPs): Rotação por solicitação, velocidade máxima

4. Requisitos de sessão

• Sem autorização: Rotação agressiva, a cada 1-5 solicitações
• Com autorização: Sticky session durante toda a operação (1-24 horas)
• Modo Híbrido: Sticky para autorização, rotating para coleta de dados

Cenário de uso	Frequência de rotação	Tamanho do pool	Atraso entre solicitações
Scraping de pesquisa Google	A cada 3-5 solicitações	200-500 IPs	5-10 seg
Monitoramento de preços Amazon	A cada 5-10 solicitações	100-300 IPs	3-7 seg
Automação Instagram	Sticky 1-2 horas	1 IP por conta	30-60 seg
Agregador de notícias	A cada 15-30 minutos	50-100 IPs	1-3 seg
Scraping de imóveis	A cada 10-20 solicitações	50-200 IPs	2-5 seg
Monitoramento de API	De acordo com limites	De acordo com limites	De acordo com doc.
Rastreamento de posições SEO	A cada 20-30 solicitações	100-300 IPs	3-8 seg
Scraping Avito/Yula	A cada 7-15 solicitações	100-200 IPs	3-6 seg

1. Round-Robin (cíclico)

Os proxies são selecionados sequencialmente da lista. Após o último, o primeiro é usado novamente. Este é o método mais simples, garantindo distribuição uniforme.

2. Aleatório (Random)

A cada vez, um proxy aleatório é selecionado do pool. Um padrão menos previsível, mais difícil de ser detectado.

3. Menos Conexões (Least Connections)

O proxy com o menor número de conexões ativas é selecionado. Ideal para solicitações paralelas.

4. Round-Robin Ponderado (Weighted Round-Robin)

Proxies com melhor desempenho recebem um peso maior e são usados com mais frequência. IPs residenciais podem ter peso 3, e datacenter, peso 1.

5. Hash de IP (IP Hash)

O proxy é selecionado com base no hash da URL ou do domínio. Garante que as solicitações para o mesmo domínio sempre usem o mesmo IP.

Períodos de resfriamento recomendados:

• Pool pequeno (10-50 IPs): 30-60 minutos entre usos do mesmo IP
• Pool médio (50-200 IPs): 15-30 minutos entre usos
• Pool grande (200+ IPs): 5-15 minutos ou sem cooldown com rotação por solicitação

1. Modo Agressivo (Foco na Velocidade)

• Rotação por solicitação — novo IP para cada solicitação
• Atrasos mínimos (0.5-1 seg entre solicitações)
• Pool grande de proxies (500+ IPs)
• Solicitações paralelas (5-15 threads)

⚠️ Riscos: Alta probabilidade de bloqueios, ciclo de vida curto do IP, pode acionar rate limiting mesmo com rotação.

📊 Adequado para: Tarefas únicas, coleta de dados públicos, sites tolerantes.

2. Modo Equilibrado (Balanced)

• Rotação baseada em solicitação — a cada 10-20 solicitações
• Atrasos médios (2-5 seg entre solicitações)
• Pool médio de proxies (100-300 IPs)
• Paralelismo moderado (5-15 threads)

✅ Vantagens: Bom equilíbrio entre velocidade e estabilidade, adequado para a maioria das tarefas.

📊 Adequado para: Monitoramento de e-commerce, scraping regular, projetos de longo prazo.

3. Modo Cauteloso (Foco na Discrição)

• Rotação baseada em tempo — a cada 15-30 minutos
• Atrasos grandes (5-15 seg entre solicitações)
• Pool menor de proxies de alta qualidade (50-100 IPs residenciais)
• Paralelismo mínimo (1-3 threads)
• Imitação de comportamento humano (atrasos aleatórios, ações do usuário)

✅ Vantagens: Risco mínimo de bloqueio, estabilidade de longo prazo, parece usuários reais.

📊 Adequado para: Redes sociais, sites altamente protegidos, trabalho com contas, inteligência competitiva.

❌ Problema 1: Recebo 429 (Too Many Requests) mesmo com rotação

Possíveis causas:

• Rotação muito frequente para o mesmo domínio
• Todos os proxies são da mesma sub-rede (detectado por ASN)
• User-Agent e outros cabeçalhos não estão sendo rotacionados
• Período de cooldown muito curto

✅ Soluções:

• Aumentar os atrasos entre as solicitações para 5-10 segundos
• Usar proxies residenciais em vez de datacenter
• Adicionar rotação de User-Agent, headers, TLS fingerprint
• Aumentar o tamanho do pool de proxies em 2-3 vezes
• Adicionar jitter (desvio aleatório) aos atrasos

❌ Problema 2: CAPTCHAs constantes ao trocar de IP

Possíveis causas:

• Proxies de datacenter com má reputação
• Rotação muito agressiva causa suspeita
• Uso de proxies públicos (gratuitos)
• A impressão digital do navegador (Browser fingerprint) não muda com a troca de IP

✅ Soluções:

• Mudar para proxies residenciais ou móveis
• Usar sticky sessions em vez de rotação constante
• Integrar serviços de resolução de CAPTCHA (2Captcha, AntiCaptcha)
• Usar navegadores headless com anti-detecção (Playwright, puppeteer-extra-plugin-stealth)
• "Aquecer" os proxies antes do trabalho principal (algumas solicitações simples)

❌ Problema 3: Perda de sessão durante a autorização

Possíveis causas:

• A rotação de IP quebra a sessão
• Cookies não são mantidos entre as solicitações
• A sticky session expirou

✅ Soluções:

• Usar sticky sessions com session_id para solicitações autorizadas
• Aumentar a duração da sticky session (1-24 horas)
• Salvar e reutilizar cookies/tokens entre sessões
• Abordagem híbrida: sticky para autenticação, rotating para coleta de dados

❌ Problema 4: Esgotamento rápido do pool de proxies

Possíveis causas:

• Rotação por solicitação muito agressiva
• Pool pequeno para grande volume de trabalho
• O período de cooldown não está sendo considerado

✅ Soluções:

• Mudar para rotação em lote (troca a cada N solicitações em vez de cada uma)
• Aumentar o pool de proxies proporcionalmente à carga
• Implementar fila com rastreamento de cooldown
• Usar o gateway de proxy rotativo do provedor

❌ Problema 5: Velocidade de scraping lenta

Possíveis causas:

• Proxies lentos (alto ping)
• Processamento sequencial em vez de paralelo
• Grandes atrasos entre solicitações
• Sobrecarga na conexão ao trocar de proxy com frequência

✅ Soluções:

• Usar connection pooling e keep-alive
• Processamento paralelo de solicitações (threading/asyncio)
• Selecionar proxies com baixo ping (filtrar por latência)
• Reduzir a frequência de rotação (burst em vez de por solicitação)
• Usar proxies mais rápidos (ISP em vez de residencial)

Métrica	Normal	Problema se
Taxa de Sucesso	> 95%	< 85%
Taxa de Erro 429	< 2%	> 10%
Taxa de Erro 403/503	< 3%	> 15%
Taxa de CAPTCHA	< 1%	> 5%
Tempo Médio de Resposta	< 3 seg	> 10 seg
Taxa de Timeout	< 1%	> 5%
IPs Únicos Usados	> 80% do pool	< 50% do pool

✅ 1. Sempre combine a rotação de IP com outras técnicas

A rotação de IP é apenas um componente. Rotacione também User-Agent, use navegadores reais (Puppeteer/Playwright), imite comportamento humano, rotacione headers e cookies.

✅ 2. Use proxies residenciais/móveis para tarefas críticas

Proxies de datacenter são mais baratos, mas têm má reputação. Para redes sociais, e-commerce e sites altamente protegidos, use apenas IPs residenciais ou móveis.

✅ 3. Implemente graceful degradation (degradação graciosa)

Em caso de aumento de erros, desacelere as solicitações automaticamente, aumente os atrasos, mude para proxies de melhor qualidade. A adaptabilidade é melhor do que uma configuração rígida.

✅ 4. Teste em uma pequena amostra antes de escalar

Antes de iniciar um grande scraping, teste a estratégia com 100-1000 solicitações. Certifique-se de que a taxa de sucesso seja > 95%, não haja bloqueios em massa e a velocidade seja aceitável.

✅ 5. Respeite robots.txt e Termos de Serviço

Scraping ético é a chave para o sucesso a longo prazo. Respeite o robots.txt, não sobrecarregue os servidores, não colete dados pessoais sem consentimento. Na Rússia, isso é regulamentado pela lei de dados pessoais.

✅ 6. Invista em proxies de qualidade

Proxies gratuitos e baratos custam mais a longo prazo: baixa velocidade, bloqueios frequentes, perda de dados, riscos de segurança. Use provedores confiáveis como ProxyCove com garantia de uptime.

Conclusões principais:

1. Não há solução universal — a escolha da estratégia depende do tipo de site, volume de dados, orçamento e requisitos de velocidade
2. Três tipos principais de rotação: baseada em tempo (estabilidade), baseada em solicitação (velocidade), aleatória (discrição) — use combinações
3. Sticky sessions são cruciais para trabalhar com autorização, carrinhos e processos multi-etapas. Proxies Rotativos são para scraping em massa
4. Qualidade é mais importante que quantidade — 50 IPs residenciais são melhores que 500 de datacenter para a maioria das tarefas em 2025
5. Monitoramento é obrigatório — rastreie taxa de sucesso, códigos de erro, tempo de resposta para otimização oportuna
6. Equilibre velocidade e discrição — scraping agressivo traz resultados de curto prazo, cauteloso traz estabilidade de longo prazo
7. Automação via provedor — use gateways de rotação em vez de soluções caseiras para economizar tempo
8. Adaptabilidade > Estaticidade — os sistemas de proteção evoluem, sua estratégia deve se adaptar

📋 Checklist antes de iniciar o scraping:

💼 Para negócios:

Se o seu negócio depende de web scraping (monitoramento de preços, inteligência competitiva, geração de leads), não economize na infraestrutura de proxy. O custo de inatividade ou bloqueio excede em muito os gastos com proxies de qualidade e a rotação correta.

🎓 Para desenvolvedores:

Invista tempo na escrita de um sistema de rotação confiável uma vez, em vez de resolver problemas de bloqueio constantemente. Use bibliotecas prontas, registre métricas, teste diferentes estratégias. A automação se pagará muitas vezes.