Automatização da troca de proxy via API: como configurar a rotação para scraping e arbitragem

A troca manual de proxies ao trabalhar com centenas de requisições é perda de tempo e dinheiro. A rotação via API permite alternar automaticamente endereços IP em caso de bloqueios, distribuir a carga e escalar scraping ou multicontas. Neste guia, vamos abordar como configurar a troca automática de proxies para diferentes tarefas: desde scraping de marketplaces até farming de contas no Facebook Ads.

O material é adequado tanto para desenvolvedores que criam scrapers em Python ou Node.js, quanto para arbitradores que utilizam ferramentas prontas com integração API.

Por que automatizar a rotação de proxies via API

A rotação automática de endereços IP via API resolve várias tarefas críticas enfrentadas por especialistas em diferentes áreas:

Principais vantagens da automação via API em comparação com a troca manual:

• Velocidade: A troca de IP ocorre em milissegundos programaticamente, sem intervenção humana
• Escalabilidade: É possível gerenciar milhares de proxies simultaneamente através de uma interface única
• Tolerância a falhas: Substituição automática de proxies não funcionais sem interromper o processo
• Flexibilidade: Configuração de regras de rotação para tarefas específicas: por tempo, por número de requisições, por geografia
• Economia: Uso otimizado de tráfego através de balanceamento de carga

Cenário típico de uso: você está fazendo scraping de preços de concorrentes no Wildberries. Sem API, você precisa monitorar manualmente os bloqueios, acessar o painel do provedor de proxy, copiar novos dados e inseri-los no script. Com API, tudo isso acontece automaticamente: o script recebe erro 429 (Too Many Requests), envia uma requisição à API do serviço de proxy, obtém um novo IP e continua funcionando.

Tipos de rotação de proxy: sticky sessions vs troca automática

Antes de configurar a automação, é importante entender a diferença entre os tipos de rotação de endereços IP. A escolha da estratégia depende da sua tarefa.

Sticky Sessions (proxies de sessão)

Ao usar sticky sessions, um endereço IP é fixado à sua sessão por um determinado tempo (geralmente de 5 a 30 minutos). A troca ocorre apenas após o término do tempo da sessão ou por sua requisição via API.

Quando usar:

• Trabalho com contas em redes sociais (Instagram, Facebook) — troca frequente de IP gera suspeitas
• Preenchimento de formulários de várias páginas, onde é necessário manter a sessão
• Teste de anúncios de uma região específica durante a sessão
• Scraping de sites com autenticação, onde a troca de IP levará ao logout

Exemplo de requisição API para criar sticky session (geralmente usa-se formato especial de login):

// Formato: username-session-SESSIONID:password
// SESSIONID — qualquer string, mesma = mesmo IP

proxy = "username-session-abc123:password@gate.proxycove.com:8000"

// Todas as requisições com session-abc123 receberão o mesmo IP durante a sessão
// Para novo IP use outro SESSIONID: session-xyz789

Rotação automática a cada requisição

O endereço IP muda a cada nova conexão ao servidor proxy. Este é o comportamento padrão de proxies residenciais sem especificar parâmetros de sessão.

Quando usar:

• Scraping em massa sem autenticação (preços, contatos, anúncios)
• Contornar rate limits agressivos em APIs públicas
• Coleta de dados de sites que banem IP após 10-20 requisições
• Verificação de disponibilidade de conteúdo de diferentes regiões

Exemplo de uso em Python (cada requisição = novo IP):

import requests

proxy = {
    "http": "http://username:password@gate.proxycove.com:8000",
    "https": "http://username:password@gate.proxycove.com:8000"
}

# Cada requisição receberá um novo IP
for i in range(10):
    response = requests.get("https://api.ipify.org", proxies=proxy)
    print(f"Requisição {i+1}, IP: {response.text}")

Rotação por temporizador

Você controla programaticamente quando trocar o IP: a cada N minutos, após M requisições ou ao receber determinados erros. Esta é uma abordagem híbrida, implementada através da API do serviço de proxy.

Quando usar:

• Otimização de consumo de tráfego — troca apenas quando necessário
• Trabalho com sites que rastreiam padrões (troca muito frequente = ban)
• Balanceamento entre anonimato e estabilidade de sessão

Fundamentos de trabalho com API de serviços de proxy

A maioria dos provedores modernos de proxy oferece duas formas de gerenciamento: através do painel web e através da API. A API fornece acesso programático às funções: obter lista de proxies, criar novas sessões, verificar saldo, estatísticas de uso.

Métodos API típicos de serviços de proxy

Embora cada provedor tenha sua própria documentação, os métodos padrão geralmente incluem:

• GET /api/v1/proxy/list — obter lista de proxies disponíveis com filtro por país, tipo
• POST /api/v1/proxy/rotate — forçar troca de IP na sessão ativa
• GET /api/v1/account/balance — verificar saldo de tráfego ou dinheiro na conta
• GET /api/v1/stats — estatísticas de uso: volume de tráfego, número de requisições, erros
• POST /api/v1/session/create — criar nova sticky session com parâmetros (país, cidade, duração)

A autenticação geralmente ocorre através de chave API no cabeçalho da requisição:

curl -X GET "https://api.provider.com/v1/proxy/list?country=US" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

A resposta geralmente vem em formato JSON:

{
  "status": "success",
  "data": {
    "proxies": [
      {
        "ip": "123.45.67.89",
        "port": 8000,
        "country": "US",
        "city": "New York",
        "protocol": "http",
        "username": "user123",
        "password": "pass456"
      }
    ],
    "total": 150,
    "available": 147
  }
}

Gerenciamento de sessões via API

Para tarefas que exigem controle sobre o tempo de vida do IP (multicontas, trabalho com contas), usa-se a criação de sessões nomeadas via API. Isso permite gerenciar programaticamente dezenas e centenas de endereços IP isolados.

Exemplo de criação de sessão com parâmetros:

POST /api/v1/session/create
{
  "country": "US",
  "state": "California",
  "session_duration": 600,  // 10 minutos
  "session_id": "facebook_account_001"
}

// Resposta:
{
  "status": "success",
  "session": {
    "id": "facebook_account_001",
    "proxy": "gate.provider.com:8000",
    "username": "user-session-facebook_account_001",
    "password": "your_password",
    "ip": "45.67.89.123",
    "expires_at": "2024-01-15T15:30:00Z"
  }
}

Agora você pode usar este proxy no seu script ou navegador antidetecção, e o IP permanecerá inalterado por 10 minutos. Para renovar a sessão, envia-se uma requisição repetida com o mesmo session_id.

Exemplos de automação em Python: requests, Selenium, Scrapy

Python é a linguagem mais popular para scraping e automação. Vamos ver exemplos de integração de rotação de proxies via API com as principais ferramentas.

Troca automática de proxy em requests

A biblioteca requests é usada para requisições HTTP simples. Para rotação automática, criaremos uma classe wrapper que troca proxies em caso de erros:

import requests
import random
import time

class RotatingProxySession:
    def __init__(self, proxy_list):
        """
        proxy_list: lista de dicionários com dados de proxy
        [{"http": "http://user:pass@ip:port", "https": "..."}]
        """
        self.proxy_list = proxy_list
        self.current_proxy = None
        self.session = requests.Session()
        self.rotate()
    
    def rotate(self):
        """Selecionar proxy aleatório da lista"""
        self.current_proxy = random.choice(self.proxy_list)
        self.session.proxies.update(self.current_proxy)
        print(f"Alternado para proxy: {self.current_proxy['http']}")
    
    def get(self, url, max_retries=3, **kwargs):
        """Requisição GET com rotação automática em caso de erros"""
        for attempt in range(max_retries):
            try:
                response = self.session.get(url, timeout=10, **kwargs)
                
                # Se recebeu bloqueio — trocar proxy
                if response.status_code in [403, 429, 503]:
                    print(f"Recebido {response.status_code}, trocando proxy...")
                    self.rotate()
                    time.sleep(2)
                    continue
                
                return response
                
            except requests.exceptions.ProxyError:
                print(f"Proxy não funciona, tentativa {attempt+1}/{max_retries}")
                self.rotate()
                time.sleep(2)
            
            except requests.exceptions.Timeout:
                print("Timeout, trocando proxy...")
                self.rotate()
                time.sleep(2)
        
        raise Exception(f"Não foi possível executar requisição após {max_retries} tentativas")

# Uso:
proxies = [
    {"http": "http://user1:pass@gate1.com:8000", "https": "http://user1:pass@gate1.com:8000"},
    {"http": "http://user2:pass@gate2.com:8000", "https": "http://user2:pass@gate2.com:8000"},
]

session = RotatingProxySession(proxies)

# Fazendo scraping do Wildberries
for page in range(1, 50):
    url = f"https://www.wildberries.ru/catalog/page={page}"
    response = session.get(url)
    print(f"Página {page}: {response.status_code}")

Integração com Selenium para automação de navegador

Selenium é usado para scraping de sites com JavaScript e automação de ações no navegador. Para trocar proxy é necessário recriar o driver, pois as configurações de proxy são definidas na inicialização:

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

class SeleniumRotatingProxy:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
        self.driver = None
        self.current_proxy_index = 0
    
    def create_driver(self):
        """Criar novo driver com proxy atual"""
        if self.driver:
            self.driver.quit()
        
        proxy = self.proxy_list[self.current_proxy_index]
        
        chrome_options = Options()
        chrome_options.add_argument(f'--proxy-server={proxy}')
        chrome_options.add_argument('--headless')  # sem GUI
        
        self.driver = webdriver.Chrome(options=chrome_options)
        print(f"Driver criado com proxy: {proxy}")
    
    def rotate(self):
        """Alternar para próximo proxy"""
        self.current_proxy_index = (self.current_proxy_index + 1) % len(self.proxy_list)
        self.create_driver()
    
    def get_with_retry(self, url, max_retries=3):
        """Abrir URL com troca automática de proxy em caso de erros"""
        for attempt in range(max_retries):
            try:
                if not self.driver:
                    self.create_driver()
                
                self.driver.get(url)
                
                # Verificação de bloqueio (por exemplo, busca de captcha)
                if "captcha" in self.driver.page_source.lower():
                    print("Captcha detectado, trocando proxy...")
                    self.rotate()
                    time.sleep(3)
                    continue
                
                return self.driver.page_source
                
            except Exception as e:
                print(f"Erro: {e}, trocando proxy (tentativa {attempt+1})")
                self.rotate()
                time.sleep(3)
        
        raise Exception("Não foi possível carregar a página")

# Uso:
proxies = [
    "http://user:pass@gate1.com:8000",
    "http://user:pass@gate2.com:8000",
]

bot = SeleniumRotatingProxy(proxies)

# Fazendo scraping do Ozon
for i in range(10):
    html = bot.get_with_retry(f"https://www.ozon.ru/category/page-{i}")
    print(f"Obtido HTML da página {i}, tamanho: {len(html)}")

bot.driver.quit()

Scrapy com middleware para rotação de proxy

Scrapy é um framework para scraping em larga escala. A rotação de proxies é implementada através de middleware, que é aplicado automaticamente a todas as requisições:

# middlewares.py

import random
from scrapy.exceptions import IgnoreRequest

class RotatingProxyMiddleware:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
    
    @classmethod
    def from_crawler(cls, crawler):
        # Obter lista de proxies das configurações
        proxy_list = crawler.settings.getlist('ROTATING_PROXY_LIST')
        return cls(proxy_list)
    
    def process_request(self, request, spider):
        # Atribuir proxy aleatório a cada requisição
        proxy = random.choice(self.proxy_list)
        request.meta['proxy'] = proxy
        spider.logger.info(f'Usando proxy: {proxy}')
    
    def process_exception(self, request, exception, spider):
        # Em caso de erro de proxy — repetir com outro
        proxy = random.choice(self.proxy_list)
        spider.logger.warning(f'Erro de proxy, alternando para: {proxy}')
        request.meta['proxy'] = proxy
        return request  # repetir requisição

# settings.py

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.RotatingProxyMiddleware': 350,
}

ROTATING_PROXY_LIST = [
    'http://user:pass@gate1.com:8000',
    'http://user:pass@gate2.com:8000',
    'http://user:pass@gate3.com:8000',
]

# Repetir requisições em caso de erros
RETRY_TIMES = 5
RETRY_HTTP_CODES = [403, 429, 500, 502, 503]

Agora cada requisição do Scrapy receberá automaticamente um proxy aleatório da lista, e em caso de erros será repetida com outro IP.

Automação em Node.js: axios, Puppeteer, Playwright

Node.js é popular para criar scrapers e bots graças à assincronia e boa integração com ferramentas de navegador. Vamos ver exemplos de rotação de proxies nas principais bibliotecas.

Axios com rotação automática

Axios é uma biblioteca para requisições HTTP. Criaremos uma classe com pool de proxies e substituição automática em caso de erros:

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

class RotatingProxyClient {
  constructor(proxyList) {
    this.proxyList = proxyList;
    this.currentIndex = 0;
  }

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

  async request(url, options = {}, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
      const proxy = this.getProxy();
      const agent = new HttpsProxyAgent(proxy);

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

        // Se recebeu bloqueio — próxima tentativa
        if ([403, 429, 503].includes(response.status)) {
          console.log(`Status ${response.status}, trocando proxy...`);
          continue;
        }

        return response.data;

      } catch (error) {
        console.log(`Erro com proxy ${proxy}: ${error.message}`);
        if (i === maxRetries - 1) throw error;
      }
    }
  }
}

// Uso:
const proxies = [
  'http://user:pass@gate1.com:8000',
  'http://user:pass@gate2.com:8000',
];

const client = new RotatingProxyClient(proxies);

(async () => {
  for (let page = 1; page <= 20; page++) {
    const data = await client.request(`https://api.example.com/products?page=${page}`);
    console.log(`Página ${page}: obtidos ${data.length} produtos`);
  }
})();

Puppeteer com rotação de proxy

Puppeteer controla o navegador Chrome. O proxy é definido ao iniciar o navegador, portanto para trocar é necessário recriar a instância:

const puppeteer = require('puppeteer');

class PuppeteerRotatingProxy {
  constructor(proxyList) {
    this.proxyList = proxyList;
    this.currentIndex = 0;
    this.browser = null;
  }

  async createBrowser() {
    if (this.browser) await this.browser.close();

    const proxy = this.proxyList[this.currentIndex];
    console.log(`Iniciando navegador com proxy: ${proxy}`);

    this.browser = await puppeteer.launch({
      headless: true,
      args: [`--proxy-server=${proxy}`]
    });
  }

  rotate() {
    this.currentIndex = (this.currentIndex + 1) % this.proxyList.length;
  }

  async scrape(url, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
      try {
        if (!this.browser) await this.createBrowser();

        const page = await this.browser.newPage();
        
        // Autenticação de proxy (se necessário)
        await page.authenticate({
          username: 'your_username',
          password: 'your_password'
        });

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

        // Verificação de captcha
        const content = await page.content();
        if (content.includes('captcha')) {
          console.log('Captcha detectado, trocando proxy...');
          this.rotate();
          await this.createBrowser();
          continue;
        }

        return content;

      } catch (error) {
        console.log(`Erro: ${error.message}, tentativa ${i+1}`);
        this.rotate();
        await this.createBrowser();
      }
    }
    throw new Error('Não foi possível carregar a página');
  }
}

// Uso:
const proxies = ['gate1.com:8000', 'gate2.com:8000'];
const scraper = new PuppeteerRotatingProxy(proxies);

(async () => {
  const html = await scraper.scrape('https://www.avito.ru/moskva');
  console.log(`Obtido HTML com tamanho: ${html.length}`);
  await scraper.browser.close();
})();

Playwright com suporte a rotação

Playwright é uma alternativa moderna ao Puppeteer com melhor desempenho. A configuração de proxy é análoga:

const { chromium } = require('playwright');

async function scrapeWithRotation(urls, proxyList) {
  let proxyIndex = 0;

  for (const url of urls) {
    const proxy = proxyList[proxyIndex];
    
    const browser = await chromium.launch({
      headless: true,
      proxy: {
        server: proxy,
        username: 'your_user',
        password: 'your_pass'
      }
    });

    const page = await browser.newPage();
    
    try {
      await page.goto(url, { timeout: 30000 });
      const title = await page.title();
      console.log(`${url} → ${title} (proxy: ${proxy})`);
    } catch (error) {
      console.log(`Erro em ${url}: ${error.message}`);
    }

    await browser.close();
    
    // Próximo proxy para próxima URL
    proxyIndex = (proxyIndex + 1) % proxyList.length;
  }
}

const urls = [
  'https://www.wildberries.ru',
  'https://www.ozon.ru',
  'https://www.avito.ru'
];

const proxies = [
  'http://gate1.com:8000',
  'http://gate2.com:8000'
];

scrapeWithRotation(urls, proxies);

Integração de API com navegadores antidetecção: Dolphin Anty, AdsPower

Para arbitradores e especialistas em SMM que trabalham com multicontas, a atribuição manual de proxy a cada perfil no Dolphin Anty ou AdsPower leva horas. A API desses navegadores permite automatizar a criação de perfis e vinculação de proxies.

Automação do Dolphin Anty via API

Dolphin Anty fornece uma API local (geralmente em http://localhost:3001/v1.0), através da qual é possível criar perfis, atribuir proxies, iniciar navegadores programaticamente.

Exemplo de script em Python para criação em massa de perfis com proxies únicos:

import requests
import json

DOLPHIN_API = "http://localhost:3001/v1.0"
API_TOKEN = "your_dolphin_api_token"

# Lista de proxies do seu provedor (obtidos via API deles)
proxies = [
    {"host": "gate1.com", "port": 8000, "login": "user1", "password": "pass1"},
    {"host": "gate2.com", "port": 8000, "login": "user2", "password": "pass2"},
]

def create_profile_with_proxy(name, proxy):
    """Criar perfil no Dolphin com vinculação de proxy"""
    
    payload = {
        "name": name,
        "tags": ["Facebook Ads", "Auto-created"],
        "proxy": {
            "type": "http",  # ou socks5
            "host": proxy["host"],
            "port": proxy["port"],
            "login": proxy["login"],
            "password": proxy["password"]
        },
        "fingerprint": {
            "os": "win",
            "webRTC": {
                "mode": "altered",
                "fillBasedOnIp": True
            },
            "canvas": {
                "mode": "noise"
            }
        }
    }
    
    headers = {
        "Authorization": f"Bearer {API_TOKEN}",
        "Content-Type": "application/json"
    }
    
    response = requests.post(
        f"{DOLPHIN_API}/browser_profiles",
        headers=headers,
        data=json.dumps(payload)
    )
    
    if response.status_code == 200:
        profile = response.json()
        print(f"✓ Perfil criado: {name}, ID: {profile['id']}")
        return profile['id']
    else:
        print(f"✗ Erro ao criar {name}: {response.text}")
        return None

# Criar 50 perfis com rotação de proxies
for i in range(50):
    proxy = proxies[i % len(proxies)]  # rotação cíclica
    profile_name = f"FB_Account_{i+1:03d}"
    create_profile_with_proxy(profile_name, proxy)

Agora você tem 50 perfis no Dolphin Anty, cada um com fingerprint único de navegador e proxy. Para iniciar o perfil programaticamente:

def start_profile(profile_id):
    """Iniciar perfil do navegador"""
    response = requests.get(
        f"{DOLPHIN_API}/browser_profiles/{profile_id}/start",
        headers={"Authorization": f"Bearer {API_TOKEN}"}
    )
    
    if response.status_code == 200:
        data = response.json()
        print(f"Perfil iniciado, porta WebDriver: {data['automation']['port']}")
        return data['automation']['port']
    else:
        print(f"Erro ao iniciar: {response.text}")

# Iniciar perfil e controlar via Selenium
port = start_profile("profile_id_here")

from selenium import webdriver
driver = webdriver.Remote(
    command_executor=f'http://127.0.0.1:{port}',
    options=webdriver.ChromeOptions()
)
driver.get("https://facebook.com")

Automação do AdsPower

AdsPower também fornece uma API local. A lógica é análoga ao Dolphin, mas com endpoints diferentes:

import requests

ADSPOWER_API = "http://local.adspower.net:50325/api/v1"

def create_adspower_profile(name, proxy):
    payload = {
        "name": name,
        "group_id": "0",  # ID do grupo de perfis
        "domain_name": "facebook.com",
        "open_urls": ["https://facebook.com"],
        "repeat_config": ["0"],
        "username": proxy["login"],
        "password": proxy["password"],
        "proxy_type": "http",
        "proxy_host": proxy["host"],
        "proxy_port": proxy["port"],
        "proxy_user": proxy["login"],
        "proxy_password": proxy["password"]
    }
    
    response = requests.post(
        f"{ADSPOWER_API}/user/create",
        json=payload
    )
    
    if response.json()["code"] == 0:
        user_id = response.json()["data"]["id"]
        print(f"✓ Perfil AdsPower criado: {name}, ID: {user_id}")
        return user_id
    else:
        print(f"✗ Erro: {response.json()['msg']}")

# Criação de perfis
for i, proxy in enumerate(proxies):
    create_adspower_profile(f"TikTok_Account_{i+1}", proxy)

Essa automação é criticamente importante ao trabalhar com dezenas de contas. Em vez de copiar manualmente dados de proxy em cada perfil, você executa um script e obtém uma infraestrutura pronta em minutos.

Tratamento de erros e fallback automático

Ao trabalhar com proxies, situações inevitáveis ocorrem: IP bloqueado pelo site alvo, servidor proxy não responde, tráfego esgotado. O tratamento adequado de erros é a chave para automação estável.

Tipos de erros e estratégias de tratamento

Implementação de sistema inteligente de retry

Em vez de simples repetição de requisição, criaremos um sistema com atraso exponencial e lista negra de proxies não funcionais:

import requests
import time
from collections import defaultdict

class SmartProxyRotator:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
        self.blacklist = set()  # IPs que não funcionam
        self.error_count = defaultdict(int)  # contador de erros por IP
        self.max_errors = 3  # após 3 erros — para lista negra
    
    def get_working_proxy(self):
        """Obter proxy que não está na lista negra"""
        available = [p for p in self.proxy_list if p not in self.blacklist]
        if not available:
            # Todos os proxies banidos — limpar lista negra
            print("⚠ Todos os proxies bloqueados, resetando lista negra")
            self.blacklist.clear()
            self.error_count.clear()
            available = self.proxy_list
        return available[0]
    
    def mark_error(self, proxy):
        """Marcar erro de proxy"""
        self.error_count[proxy] += 1
        if self.error_count[proxy] >= self.max_errors:
            self.blacklist.add(proxy)
            print(f"✗ Proxy {proxy} adicionado à lista negra")
    
    def request_with_retry(self, url, max_retries=5):
        """Requisição com tentativas inteligentes"""
        for attempt in range(max_retries):
            proxy = self.get_working_proxy()
            
            try:
                # Atraso exponencial: 1s, 2s, 4s, 8s...
                if attempt > 0:
                    delay = 2 ** attempt
                    print(f"Aguardando {delay}s antes da tentativa {attempt+1}")
                    time.sleep(delay)
                
                response = requests.get(
                    url,
                    proxies={"http": proxy, "https": proxy},
                    timeout=15
                )
                
                # Sucesso — resetar contador de erros
                if response.status_code == 200:
                    self.error_count[proxy] = 0
                    return response
                
                # Bloqueio — trocar proxy
                elif response.status_code in [403, 429]:
                    print(f"Status {response.status_code}, trocando proxy")
                    self.mark_error(proxy)
                    continue
                
            except requests.exceptions.ProxyError:
                print(f"ProxyError com {proxy}")
                self.mark_error(proxy)
                
            except requests.exceptions.Timeout:
                print(f"Timeout com {proxy}")
                self.mark_error(proxy)
        
        raise Exception(f"Não foi possível executar requisição após {max_retries} tentativas")

# Uso:
proxies = [
    "http://user:pass@gate1.com:8000",
    "http://user:pass@gate2.com:8000",
    "http://user:pass@gate3.com:8000",
]

rotator = SmartProxyRotator(proxies)

for i in range(100):
    try:
        response = rotator.request_with_retry(f"https://api.example.com/data?page={i}")
        print(f"✓ Página {i}: {len(response.text)} bytes")
    except Exception as e:
        print(f"✗ Erro crítico na página {i}: {e}")

Monitoramento e alertas

Para sistemas de produção, é importante monitorar a saúde do pool de proxies em tempo real. Adicione registro de métricas:

import logging
from datetime import datetime

class ProxyMonitor:
    def __init__(self):
        self.stats = {
            "total_requests": 0,
            "successful": 0,
            "failed": 0,
            "proxy_errors": defaultdict(int),
            "start_time": datetime.now()
        }
        
        # Configuração de logging
        logging.basicConfig(
            filename='proxy_rotation.log',
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
    
    def log_request(self, proxy, success, error=None):
        self.stats["total_requests"] += 1
        
        if success:
            self.stats["successful"] += 1
            logging.info(f"✓ Sucesso com {proxy}")
        else:
            self.stats["failed"] += 1
            self.stats["proxy_errors"][proxy] += 1
            logging.error(f"✗ Erro com {proxy}: {error}")
    
    def get_report(self):
        uptime = datetime.now() - self.stats["start_time"]
        success_rate = (self.stats["successful"] / self.stats["total_requests"] * 100) if self.stats["total_requests"] > 0 else 0
        
        return f"""
=== Relatório de rotação de proxies ===
Tempo de execução: {uptime}
Total de requisições: {self.stats["total_requests"]}
Bem-sucedidas: {self.stats["successful"]} ({success_rate:.1f}%)
Erros: {self.stats["failed"]}

Proxies problemáticos:
{self._format_errors()}
        """
    
    def _format_errors(self):
        sorted_errors = sorted(
            self.stats["proxy_errors"].items(),
            key=lambda x: x[1],
            reverse=True
        )
        return "\n".join([f"  {proxy}: {count} erros" for proxy, count in sorted_errors[:5]])

# Integração com rotator
monitor = ProxyMonitor()

# No loop de requisições:
try:
    response = rotator.request_with_retry(url)
    monitor.log_request(current_proxy, success=True)
except Exception as e:
    monitor.log_request(current_proxy, success=False, error=str(e))

Melhores práticas e otimização de consumo de tráfego

Para maximizar a eficiência da rotação de proxies e minimizar custos, siga estas recomendações:

• Use sticky sessions quando possível: Para tarefas que não exigem troca frequente de IP, sessões fixas economizam tráfego e reduzem a probabilidade de bloqueios
• Implemente cache inteligente: Armazene respostas bem-sucedidas para evitar requisições repetidas desnecessárias
• Distribua a carga uniformemente: Use algoritmos de balanceamento (round-robin, least-connections) para não sobrecarregar proxies individuais
• Monitore métricas em tempo real: Taxa de sucesso, latência média, consumo de tráfego por proxy
• Configure timeouts adequados: Timeouts muito curtos causam falsos positivos; muito longos desperdiçam tempo
• Use geolocalização estrategicamente: Proxies do país alvo geralmente têm melhor desempenho e menor taxa de bloqueio

Conclusão

A automação de rotação de proxies via API é essencial para operações de scraping, arbitragem e multicontas em escala profissional. Com as ferramentas e técnicas apresentadas neste guia, você pode:

• Automatizar completamente o gerenciamento de proxies em seus projetos
• Implementar sistemas robustos de tratamento de erros e fallback
• Integrar rotação de proxies com navegadores antidetecção
• Otimizar custos através de uso inteligente de tráfego
• Escalar operações sem intervenção manual

Lembre-se de que a escolha do provedor de proxies é tão importante quanto a implementação técnica. Procure serviços com API bem documentada, suporte responsivo e pool de IPs de qualidade.