Automazione del cambio proxy tramite API: come impostare la rotazione per scraping e arbitraggio

La rotazione manuale dei proxy quando si lavora con centinaia di richieste è una perdita di tempo e denaro. La rotazione API consente di cambiare automaticamente gli indirizzi IP in caso di blocchi, distribuire il carico e scalare lo scraping o il multi-accounting. In questa guida analizzeremo come configurare la rotazione automatica dei proxy per diverse attività: dallo scraping dei marketplace al farming di account su Facebook Ads.

Il materiale è adatto sia agli sviluppatori che scrivono scraper in Python o Node.js, sia agli arbitraggisti che utilizzano strumenti pronti con integrazione API.

Perché è necessaria l'automazione della rotazione proxy tramite API

La rotazione automatica degli indirizzi IP tramite API risolve diversi problemi critici che gli specialisti affrontano in vari settori:

Principali vantaggi dell'automazione API rispetto alla rotazione manuale:

• Velocità: Il cambio IP avviene in millisecondi in modo programmatico, senza intervento umano
• Scalabilità: È possibile gestire migliaia di proxy simultaneamente attraverso un'interfaccia unica
• Tolleranza ai guasti: Sostituzione automatica dei proxy non funzionanti senza interruzione del processo
• Flessibilità: Configurazione delle regole di rotazione per attività specifiche: per tempo, per numero di richieste, per geografia
• Risparmio: Utilizzo ottimale del traffico attraverso il bilanciamento del carico

Scenario tipico di utilizzo: state facendo scraping dei prezzi dei concorrenti su Wildberries. Senza API dovete monitorare manualmente i blocchi, accedere al pannello del provider proxy, copiare i nuovi dati, inserirli nello script. Con l'API tutto questo avviene automaticamente: lo script riceve l'errore 429 (Too Many Requests), invia una richiesta all'API del servizio proxy, ottiene un nuovo IP e continua a funzionare.

Tipi di rotazione proxy: sticky sessions vs rotazione automatica

Prima di configurare l'automazione, è importante comprendere la differenza tra i tipi di rotazione degli indirizzi IP. La scelta della strategia dipende dalla vostra attività.

Sticky Sessions (proxy di sessione)

Quando si utilizzano sticky sessions, un indirizzo IP viene assegnato alla vostra sessione per un determinato periodo di tempo (solitamente da 5 a 30 minuti). Il cambio avviene solo dopo la scadenza del tempo di sessione o su vostra richiesta API.

Quando utilizzare:

• Lavoro con account sui social network (Instagram, Facebook) — il cambio frequente di IP suscita sospetti
• Compilazione di moduli multi-pagina dove è necessario mantenere la sessione
• Test di pubblicità da una regione specifica durante la sessione
• Scraping di siti con autenticazione, dove il cambio IP porterebbe al logout

Esempio di richiesta API per creare una sticky session (solitamente si usa un formato di login speciale):

// Formato: username-session-SESSIONID:password
// SESSIONID — qualsiasi stringa, stessa = stesso IP

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

// Tutte le richieste con session-abc123 riceveranno lo stesso IP per la durata della sessione
// Per un nuovo IP utilizzare un SESSIONID diverso: session-xyz789

Rotazione automatica ad ogni richiesta

L'indirizzo IP cambia ad ogni nuova connessione al server proxy. Questo è il comportamento standard dei proxy residenziali senza specificare parametri di sessione.

Quando utilizzare:

• Scraping massivo senza autenticazione (prezzi, contatti, annunci)
• Bypass di rate limits aggressivi su API pubbliche
• Raccolta dati da siti che bannano gli IP dopo 10-20 richieste
• Verifica della disponibilità di contenuti da diverse regioni

Esempio di utilizzo in Python (ogni richiesta = nuovo IP):

import requests

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

# Ogni richiesta riceverà un nuovo IP
for i in range(10):
    response = requests.get("https://api.ipify.org", proxies=proxy)
    print(f"Richiesta {i+1}, IP: {response.text}")

Rotazione a tempo

Controllate programmaticamente quando cambiare IP: ogni N minuti, dopo M richieste o alla ricezione di determinati errori. Questo è un approccio ibrido che viene implementato tramite l'API del servizio proxy.

Quando utilizzare:

• Ottimizzazione del consumo di traffico — cambio solo quando necessario
• Lavoro con siti che tracciano i pattern (cambio troppo frequente = ban)
• Bilanciamento tra anonimato e stabilità della sessione

Fondamenti del lavoro con le API dei servizi proxy

La maggior parte dei provider proxy moderni fornisce due modi di gestione: tramite pannello web e tramite API. L'API offre accesso programmatico alle funzioni: ottenere l'elenco dei proxy, creare nuove sessioni, verificare il saldo, statistiche di utilizzo.

Metodi API tipici dei servizi proxy

Sebbene ogni provider abbia la propria documentazione, i metodi standard solitamente includono:

• GET /api/v1/proxy/list — ottenere l'elenco dei proxy disponibili con filtro per paese, tipo
• POST /api/v1/proxy/rotate — cambiare forzatamente l'IP nella sessione attiva
• GET /api/v1/account/balance — verificare il saldo di traffico o denaro sul conto
• GET /api/v1/stats — statistiche di utilizzo: volume di traffico, numero di richieste, errori
• POST /api/v1/session/create — creare una nuova sticky session con parametri (paese, città, durata)

L'autenticazione avviene solitamente tramite chiave API nell'intestazione della richiesta:

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

La risposta arriva solitamente in 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
  }
}

Gestione delle sessioni tramite API

Per attività che richiedono il controllo sul tempo di vita dell'IP (multi-accounting, lavoro con account), si utilizza la creazione di sessioni nominate tramite API. Questo consente di gestire programmaticamente decine e centinaia di indirizzi IP isolati.

Esempio di creazione di una sessione con parametri:

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

// Risposta:
{
  "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"
  }
}

Ora potete utilizzare questo proxy nel vostro script o browser antidetect, e l'IP rimarrà invariato per 10 minuti. Per prolungare la sessione, viene inviata una richiesta ripetuta con lo stesso session_id.

Esempi di automazione in Python: requests, Selenium, Scrapy

Python è il linguaggio più popolare per lo scraping e l'automazione. Esaminiamo esempi di integrazione della rotazione API proxy con gli strumenti principali.

Rotazione automatica dei proxy in requests

La libreria requests viene utilizzata per semplici richieste HTTP. Per la rotazione automatica creeremo una classe wrapper che cambia proxy in caso di errori:

import requests
import random
import time

class RotatingProxySession:
    def __init__(self, proxy_list):
        """
        proxy_list: lista di dizionari con dati 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):
        """Selezionare un proxy casuale dalla lista"""
        self.current_proxy = random.choice(self.proxy_list)
        self.session.proxies.update(self.current_proxy)
        print(f"Passati al proxy: {self.current_proxy['http']}")
    
    def get(self, url, max_retries=3, **kwargs):
        """Richiesta GET con rotazione automatica in caso di errori"""
        for attempt in range(max_retries):
            try:
                response = self.session.get(url, timeout=10, **kwargs)
                
                # Se ricevuto blocco — cambiare proxy
                if response.status_code in [403, 429, 503]:
                    print(f"Ricevuto {response.status_code}, cambiamo proxy...")
                    self.rotate()
                    time.sleep(2)
                    continue
                
                return response
                
            except requests.exceptions.ProxyError:
                print(f"Proxy non funziona, tentativo {attempt+1}/{max_retries}")
                self.rotate()
                time.sleep(2)
            
            except requests.exceptions.Timeout:
                print("Timeout, cambiamo proxy...")
                self.rotate()
                time.sleep(2)
        
        raise Exception(f"Impossibile eseguire la richiesta dopo {max_retries} tentativi")

# Utilizzo:
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)

# Scraping di Wildberries
for page in range(1, 50):
    url = f"https://www.wildberries.ru/catalog/page={page}"
    response = session.get(url)
    print(f"Pagina {page}: {response.status_code}")

Integrazione con Selenium per l'automazione browser

Selenium viene utilizzato per lo scraping di siti con JavaScript e l'automazione di azioni nel browser. Per cambiare proxy è necessario ricreare il driver, poiché le impostazioni proxy vengono definite all'inizializzazione:

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):
        """Creare un nuovo driver con il proxy corrente"""
        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')  # senza GUI
        
        self.driver = webdriver.Chrome(options=chrome_options)
        print(f"Creato driver con proxy: {proxy}")
    
    def rotate(self):
        """Passare al proxy successivo"""
        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):
        """Aprire URL con cambio automatico proxy in caso di errori"""
        for attempt in range(max_retries):
            try:
                if not self.driver:
                    self.create_driver()
                
                self.driver.get(url)
                
                # Verifica blocco (ad esempio, ricerca captcha)
                if "captcha" in self.driver.page_source.lower():
                    print("Rilevato captcha, cambiamo proxy...")
                    self.rotate()
                    time.sleep(3)
                    continue
                
                return self.driver.page_source
                
            except Exception as e:
                print(f"Errore: {e}, cambiamo proxy (tentativo {attempt+1})")
                self.rotate()
                time.sleep(3)
        
        raise Exception("Impossibile caricare la pagina")

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

bot = SeleniumRotatingProxy(proxies)

# Scraping di Ozon
for i in range(10):
    html = bot.get_with_retry(f"https://www.ozon.ru/category/page-{i}")
    print(f"Ottenuto HTML pagina {i}, lunghezza: {len(html)}")

bot.driver.quit()

Scrapy con middleware per la rotazione proxy

Scrapy è un framework per lo scraping su larga scala. La rotazione proxy viene implementata tramite middleware, che si applica automaticamente a tutte le richieste:

# 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):
        # Ottenere lista proxy dalle impostazioni
        proxy_list = crawler.settings.getlist('ROTATING_PROXY_LIST')
        return cls(proxy_list)
    
    def process_request(self, request, spider):
        # Assegnare proxy casuale ad ogni richiesta
        proxy = random.choice(self.proxy_list)
        request.meta['proxy'] = proxy
        spider.logger.info(f'Utilizziamo proxy: {proxy}')
    
    def process_exception(self, request, exception, spider):
        # In caso di errore proxy — riprovare con un altro
        proxy = random.choice(self.proxy_list)
        spider.logger.warning(f'Errore proxy, passiamo a: {proxy}')
        request.meta['proxy'] = proxy
        return request  # ripetere richiesta

# 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',
]

# Ripetere richieste in caso di errori
RETRY_TIMES = 5
RETRY_HTTP_CODES = [403, 429, 500, 502, 503]

Ora ogni richiesta Scrapy riceverà automaticamente un proxy casuale dalla lista, e in caso di errori verrà ripetuta con un IP diverso.

Automazione in Node.js: axios, Puppeteer, Playwright

Node.js è popolare per la creazione di scraper e bot grazie all'asincronia e alla buona integrazione con gli strumenti browser. Esaminiamo esempi di rotazione proxy nelle librerie principali.

Axios con rotazione automatica

Axios è una libreria per richieste HTTP. Creeremo una classe con un pool di proxy e sostituzione automatica in caso di errori:

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 ricevuto blocco — tentativo successivo
        if ([403, 429, 503].includes(response.status)) {
          console.log(`Status ${response.status}, cambiamo proxy...`);
          continue;
        }

        return response.data;

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

// Utilizzo:
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(`Pagina ${page}: ottenuti ${data.length} prodotti`);
  }
})();

Puppeteer con rotazione proxy

Puppeteer gestisce il browser Chrome. Il proxy viene impostato all'avvio del browser, quindi per cambiarlo è necessario ricreare l'istanza:

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(`Avviamo browser con 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();
        
        // Autenticazione proxy (se richiesta)
        await page.authenticate({
          username: 'your_username',
          password: 'your_password'
        });

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

        // Verifica captcha
        const content = await page.content();
        if (content.includes('captcha')) {
          console.log('Rilevato captcha, cambiamo proxy...');
          this.rotate();
          await this.createBrowser();
          continue;
        }

        return content;

      } catch (error) {
        console.log(`Errore: ${error.message}, tentativo ${i+1}`);
        this.rotate();
        await this.createBrowser();
      }
    }
    throw new Error('Impossibile caricare la pagina');
  }
}

// Utilizzo:
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(`Ottenuto HTML di lunghezza: ${html.length}`);
  await scraper.browser.close();
})();

Playwright con supporto rotazione

Playwright è un'alternativa moderna a Puppeteer con migliori prestazioni. La configurazione proxy è analoga:

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(`Errore su ${url}: ${error.message}`);
    }

    await browser.close();
    
    // Proxy successivo per URL successivo
    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);

Integrazione API con browser antidetect: Dolphin Anty, AdsPower

Per gli arbitraggisti e gli specialisti SMM che lavorano con il multi-accounting, l'assegnazione manuale di proxy a ogni profilo in Dolphin Anty o AdsPower richiede ore. Le API di questi browser consentono di automatizzare la creazione di profili e l'associazione dei proxy.

Automazione di Dolphin Anty tramite API

Dolphin Anty fornisce un'API locale (solitamente su http://localhost:3001/v1.0), attraverso la quale è possibile creare profili, assegnare proxy, avviare browser programmaticamente.

Esempio di script in Python per la creazione massiva di profili con proxy unici:

import requests
import json

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

# Lista proxy dal vostro provider (ottenuti tramite la loro API)
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):
    """Creare profilo in Dolphin con associazione proxy"""
    
    payload = {
        "name": name,
        "tags": ["Facebook Ads", "Auto-created"],
        "proxy": {
            "type": "http",  # o 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"✓ Creato profilo: {name}, ID: {profile['id']}")
        return profile['id']
    else:
        print(f"✗ Errore creazione {name}: {response.text}")
        return None

# Creare 50 profili con rotazione proxy
for i in range(50):
    proxy = proxies[i % len(proxies)]  # rotazione ciclica
    profile_name = f"FB_Account_{i+1:03d}"
    create_profile_with_proxy(profile_name, proxy)

Ora avete 50 profili in Dolphin Anty, ognuno con un'impronta digitale del browser unica e un proxy. Per avviare il profilo programmaticamente:

def start_profile(profile_id):
    """Avviare profilo browser"""
    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"Profilo avviato, porta WebDriver: {data['automation']['port']}")
        return data['automation']['port']
    else:
        print(f"Errore avvio: {response.text}")

# Avviare profilo e gestire tramite 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")

Automazione di AdsPower

AdsPower fornisce anche un'API locale. La logica è analoga a Dolphin, ma con endpoint diversi:

import requests

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

def create_adspower_profile(name, proxy):
    payload = {
        "name": name,
        "group_id": "0",  # ID gruppo profili
        "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"✓ Creato profilo AdsPower: {name}, ID: {user_id}")
        return user_id
    else:
        print(f"✗ Errore: {response.json()['msg']}")

# Creazione profili
for i, proxy in enumerate(proxies):
    create_adspower_profile(f"TikTok_Account_{i+1}", proxy)

Tale automazione è fondamentale quando si lavora con decine di account. Invece di copiare manualmente i dati proxy in ogni profilo, eseguite uno script e ottenete un'infrastruttura pronta in pochi minuti.

Gestione degli errori e fallback automatico

Quando si lavora con i proxy sono inevitabili situazioni: IP bloccato dal sito target, server proxy non risponde, traffico esaurito. La corretta gestione degli errori è la chiave per un'automazione stabile.

Tipi di errori e strategie di gestione

Implementazione di un sistema di retry intelligente

Invece di una semplice ripetizione della richiesta, creeremo un sistema con ritardo esponenziale e blacklist dei proxy non funzionanti:

import requests
import time
from collections import defaultdict

class SmartProxyRotator:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
        self.blacklist = set()  # IP che non funzionano
        self.error_count = defaultdict(int)  # contatore errori per IP
        self.max_errors = 3  # dopo 3 errori — in blacklist
    
    def get_working_proxy(self):
        """Ottenere proxy che non è in blacklist"""
        available = [p for p in self.proxy_list if p not in self.blacklist]
        if not available:
            # Tutti i proxy bannati — pulire blacklist
            print("⚠ Tutti i proxy bloccati, resettiamo blacklist")
            self.blacklist.clear()
            self.error_count.clear()
            available = self.proxy_list
        return available[0]
    
    def mark_error(self, proxy):
        """Segnare errore proxy"""
        self.error_count[proxy] += 1
        if self.error_count[proxy] >= self.max_errors:
            self.blacklist.add(proxy)
            print(f"✗ Proxy {proxy} aggiunto alla blacklist")
    
    def request_with_retry(self, url, max_retries=5):
        """Richiesta con retry intelligenti"""
        for attempt in range(max_retries):
            proxy = self.get_working_proxy()
            
            try:
                # Ritardo esponenziale: 1s, 2s, 4s, 8s...
                if attempt > 0:
                    delay = 2 ** attempt
                    print(f"Attesa {delay}s prima del tentativo {attempt+1}")
                    time.sleep(delay)
                
                response = requests.get(
                    url,
                    proxies={"http": proxy, "https": proxy},
                    timeout=15
                )
                
                # Successo — resettare contatore errori
                if response.status_code == 200:
                    self.error_count[proxy] = 0
                    return response
                
                # Blocco — cambiare proxy
                elif response.status_code in [403, 429]:
                    print(f"Status {response.status_code}, cambiamo proxy")
                    self.mark_error(proxy)
                    continue
                
            except requests.exceptions.ProxyError:
                print(f"ProxyError con {proxy}")
                self.mark_error(proxy)
                
            except requests.exceptions.Timeout:
                print(f"Timeout con {proxy}")
                self.mark_error(proxy)
        
        raise Exception(f"Impossibile eseguire richiesta dopo {max_retries} tentativi")

# Utilizzo:
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"✓ Pagina {i}: {len(response.text)} byte")
    except Exception as e:
        print(f"✗ Errore critico sulla pagina {i}: {e}")

Monitoraggio e alert

Per i sistemi in produzione è importante monitorare lo stato del pool di proxy in tempo reale. Aggiungete il logging delle metriche:

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()
        }
        
        # Configurazione 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"✓ Successo con {proxy}")
        else:
            self.stats["failed"] += 1
            self.stats["proxy_errors"][proxy] += 1
            logging.error(f"✗ Errore con {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"""
=== Report rotazione proxy ===
Tempo di attività: {uptime}
Totale richieste: {self.stats["total_requests"]}
Riuscite: {self.stats["successful"]} ({success_rate:.1f}%)
Errori: {self.stats["failed"]}

Proxy problematici:
{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} errori" for proxy, count in sorted_errors[:5]])

# Integrazione con rotator
monitor = ProxyMonitor()

# Nel ciclo delle richieste:
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))

# Stampare report periodicamente
print(monitor.get_report())

Best practice e ottimizzazione del consumo di traffico

L'automazione della rotazione proxy richiede un approccio equilibrato per massimizzare l'efficienza e minimizzare i costi. Ecco le pratiche consigliate:

1. Utilizzare sticky sessions quando possibile

La rotazione ad ogni richiesta consuma più traffico e può sembrare sospetta. Se la vostra attività lo permette, mantenete lo stesso IP per 5-10 minuti:

# Invece di cambiare IP ad ogni richiesta:
for i in range(1000):
    response = requests.get(url, proxies=get_random_proxy())

# Usare sessioni:
session_id = f"session_{int(time.time())}"
proxy = f"user-session-{session_id}:pass@gate.com:8000"

for i in range(1000):
    response = requests.get(url, proxies={"http": proxy})
    if i % 100 == 0:  # Cambiare ogni 100 richieste
        session_id = f"session_{int(time.time())}"
        proxy = f"user-session-{session_id}:pass@gate.com:8000"

2. Implementare rate limiting intelligente

Non inviate richieste alla massima velocità possibile. Aggiungete ritardi casuali per simulare il comportamento umano:

import random
import time

def human_like_delay():
    """Ritardo casuale tra 1 e 5 secondi"""
    delay = random.uniform(1, 5)
    time.sleep(delay)

for url in urls:
    response = session.get(url)
    process_data(response)
    human_like_delay()  # Pausa tra richieste

3. Caching delle risposte

Evitate richieste duplicate memorizzando nella cache le risposte già ottenute:

import hashlib
import json

class CachedProxySession:
    def __init__(self, proxy_rotator):
        self.rotator = proxy_rotator
        self.cache = {}
    
    def get_cached(self, url):
        cache_key = hashlib.md5(url.encode()).hexdigest()
        
        if cache_key in self.cache:
            print(f"✓ Cache hit per {url}")
            return self.cache[cache_key]
        
        response = self.rotator.request_with_retry(url)
        self.cache[cache_key] = response
        return response

4. Geo-targeting ottimale

Utilizzate proxy dalla stessa regione del sito target per ridurre i sospetti e migliorare la velocità:

# Per siti russi — proxy russi
ru_proxies = get_proxies(country="RU")

# Per Amazon.com — proxy USA
us_proxies = get_proxies(country="US")

# Per siti regionali — proxy dalla stessa città
moscow_proxies = get_proxies(country="RU", city="Moscow")

5. Monitoraggio del consumo

Tracciate quanto traffico consuma ogni attività per ottimizzare i costi:

class TrafficMonitor:
    def __init__(self):
        self.traffic_by_task = defaultdict(int)
    
    def log_request(self, task_name, response):
        # Calcolare dimensione risposta
        size = len(response.content)
        self.traffic_by_task[task_name] += size
    
    def get_report(self):
        total = sum(self.traffic_by_task.values())
        print(f"Traffico totale: {total / 1024 / 1024:.2f} MB\n")
        
        for task, traffic in self.traffic_by_task.items():
            percentage = (traffic / total * 100) if total > 0 else 0
            print(f"{task}: {traffic / 1024 / 1024:.2f} MB ({percentage:.1f}%)")

Conclusioni

L'automazione della rotazione proxy tramite API trasforma il modo in cui lavorate con lo scraping, il multi-accounting e l'arbitraggio. Invece di gestire manualmente centinaia di IP, ottenete un sistema che:

• Cambia automaticamente i proxy in caso di blocchi
• Distribuisce il carico tra migliaia di indirizzi IP
• Si adatta ai rate limits dei siti target
• Scala da 10 a 10.000 richieste al giorno senza modifiche al codice
• Riduce i costi attraverso l'uso ottimale del traffico

I punti chiave da ricordare:

Per iniziare con l'automazione della rotazione proxy, avete bisogno di un provider affidabile con API ben documentate. ProxyCove offre proxy residenziali e mobili con supporto completo API, sticky sessions configurabili e geo-targeting preciso — tutto ciò di cui avete bisogno per implementare gli esempi di questa guida.

Iniziate con un piccolo progetto: automatizzate la rotazione per 10-20 richieste, testate la gestione degli errori, poi scalate gradualmente. L'investimento di tempo nell'impostazione dell'automazione si ripaga già dopo il primo giorno di lavoro stabile senza intervento manuale.