Come evitare il blocco durante richieste frequenti all'API di Wildberries, Ozon e Avito

Se ti occupi di monitorare i prezzi dei concorrenti, di fare parsing delle giacenze dei prodotti o di pubblicare automaticamente annunci sui marketplace, sicuramente hai già affrontato i blocchi. Le API di Wildberries, Ozon, Yandex.Market e Avito si proteggono attivamente dall'automazione: limitano il numero di richieste, bloccano gli indirizzi IP e richiedono CAPTCHA. In questa guida analizzeremo perché si verificano i blocchi e come configurare il parser in modo da lavorare stabilmente per mesi senza ban.

Perché i marketplace bloccano le richieste frequenti alle API

I marketplace spendono enormi somme di denaro per mantenere l'infrastruttura: server, database, CDN. Quando fai migliaia di richieste al minuto per il parsing dei prezzi, crei un carico aggiuntivo sui loro sistemi. Ma la principale ragione dei blocchi non è tecnica, ma orientata al business.

Principali motivi dei blocchi:

• Protezione dei dati competitivi. Wildberries e Ozon non vogliono che i concorrenti ottengano facilmente informazioni sui prezzi, le giacenze e i prodotti popolari. Questi dati sono un segreto commerciale.
• Riduzione del carico sui server. Un parser può generare tante richieste quanto 10.000 normali acquirenti. Questo aumenta i costi di hosting.
• Combattere le manipolazioni e lo spam. I sistemi automatici vengono utilizzati per gonfiare visualizzazioni, recensioni e pubblicazione di annunci su Avito.
• Monetizzazione delle API. Alcuni marketplace offrono API ufficiali a pagamento con limiti. Bloccando il parsing gratuito, stimolano l'acquisto di accesso.

Ad esempio, se monitori i prezzi di 5000 prodotti ogni ora, questo equivale a 120.000 richieste al giorno. Da un singolo indirizzo IP, questo appare sospetto, e il sistema di protezione del marketplace bloccherà rapidamente il tuo accesso.

Quali metodi di protezione utilizzano Wildberries, Ozon e Avito

I moderni marketplace utilizzano una protezione multilivello contro il parsing. Comprendere questi meccanismi aiuterà a configurare correttamente il bypass dei blocchi.

Wildberries utilizza una protezione aggressiva: limite di circa 200-300 richieste all'ora da un singolo IP, controllo User-Agent e sfide JavaScript. Se superi il limite, riceverai un HTTP 429 (Troppe Richieste) o 403 (Vietato).

Ozon è più tollerante al parsing tramite API, ma blocca attivamente gli IP dei data center. Utilizzano servizi di identificazione del tipo di IP (DataCenter vs Residenziale), quindi i normali proxy spesso non funzionano.

Avito protegge l'API dalla pubblicazione di massa di annunci e dal parsing dei contatti. Qui è importante la geolocalizzazione: se pubblichi un annuncio a Kazan, l'IP deve provenire da Kazan, altrimenti la moderazione bloccherà la pubblicazione.

Limitazione della velocità: come configurare correttamente i ritardi tra le richieste

La limitazione della velocità è una restrizione artificiale della velocità delle richieste, affinché la tua attività appaia come quella di un normale utente. La regola principale è: meglio lentamente ma stabilmente, che velocemente e con un ban.

Impostazioni consigliate per i marketplace più popolari:

Come implementare ritardi randomizzati: Non utilizzare intervalli fissi come "esattamente 3 secondi" — questo appare come un bot. Aggiungi casualità: da 2 a 5 secondi. La maggior parte dei parser supporta questo tramite impostazioni.

Ad esempio, in Python con la libreria requests appare così:

import time
import random
import requests

def make_request(url, proxies):
    response = requests.get(url, proxies=proxies)
    # Ritardo randomizzato da 2 a 5 secondi
    delay = random.uniform(2.0, 5.0)
    time.sleep(delay)
    return response

# Esempio di utilizzo
proxy = {
    'http': 'http://username:password@proxy.example.com:8000',
    'https': 'http://username:password@proxy.example.com:8000'
}

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

Punto importante: Dopo ogni 100-200 richieste, fai una lunga pausa (10-20 minuti) o cambia IP. Questo imita il comportamento di un umano che naviga tra i prodotti e poi si distrae con altre attività.

Rotazione dei proxy per distribuire il carico

Anche con i ritardi corretti, un singolo IP non reggerà a lungo carico. La soluzione è la rotazione dei proxy: distribuire le richieste tra molti indirizzi IP. Questa è la base per un parsing stabile dei marketplace.

Tipi di proxy per il parsing dei marketplace:

Per il parsing di Wildberries e Ozon, ti consigliamo di utilizzare proxy residenziali — hanno IP di veri utenti domestici, quindi i marketplace non possono distinguerli dai normali acquirenti. I proxy dei data center funzionano male qui: Ozon e Wildberries mantengono blacklist di tali IP.

Strategie di rotazione dei proxy:

• Rotazione dopo N richieste. Cambia IP dopo ogni 100-300 richieste. Questo è un equilibrio ottimale tra efficienza e sicurezza.
• Rotazione temporale. Cambia IP ogni 30-60 minuti. Adatto per sessioni di parsing lunghe.
• Sticky sessions. Usa un IP per tutte le richieste a un prodotto/categoria, poi cambia. Questo riduce la sospettosità.
• Geolocalizzazione. Per Avito è obbligatorio: fai parsing degli annunci di Mosca tramite IP di Mosca, di Kazan — tramite IP di Kazan.

La maggior parte dei fornitori di proxy residenziali offre rotazione automatica: ricevi un endpoint e l'IP cambia automaticamente con una frequenza impostata o dopo ogni richiesta. Questo semplifica la configurazione del parser.

Esempio di configurazione di un pool di proxy in Python:

import requests
import random

# Lista di proxy (può essere caricata da un file)
proxy_list = [
    'http://user:pass@proxy1.example.com:8000',
    'http://user:pass@proxy2.example.com:8000',
    'http://user:pass@proxy3.example.com:8000',
    # ... altre 50-100 proxy
]

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

# Utilizzo
for product_id in product_list:
    proxy = get_random_proxy()  # Proxy casuale per ogni richiesta
    response = requests.get(url, proxies=proxy)
    # Elaborazione...

Configurazione delle intestazioni e fingerprint per imitare il browser

I marketplace analizzano non solo gli IP e la frequenza delle richieste, ma anche le intestazioni HTTP. Se il tuo parser invia richieste con intestazioni predefinite della libreria (ad esempio, python-requests/2.28.0), viene immediatamente identificato come bot.

Intestazioni obbligatorie per imitare il browser:

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
    'Accept-Language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
    'Accept-Encoding': 'gzip, deflate, br',
    'DNT': '1',
    'Connection': 'keep-alive',
    'Upgrade-Insecure-Requests': '1',
    'Sec-Fetch-Dest': 'document',
    'Sec-Fetch-Mode': 'navigate',
    'Sec-Fetch-Site': 'none',
    'Cache-Control': 'max-age=0',
    'Referer': 'https://www.google.com/'
}

Punti importanti:

• User-Agent deve corrispondere a un vero browser. Usa versioni attuali di Chrome, Firefox, Safari. Cambia User-Agent ogni 100-200 richieste.
• Accept-Language deve corrispondere alla geografia del proxy. Se usi IP russi — imposta ru-RU, per quelli ucraini — uk-UA.
• Referer mostra da dove è arrivato l'utente. Per la prima richiesta usa Google/Yandex, per le successive — pagine interne del marketplace.
• Le intestazioni Sec-Fetch-* aggiungono realismo. I browser moderni le inviano automaticamente.

Fingerprinting TLS: I sistemi di protezione avanzati (Ozon, Wildberries) analizzano i parametri della connessione TLS: ordine delle suite di cifratura, estensioni, versione del protocollo. Le librerie standard di Python/Node.js hanno un fingerprint diverso dai browser.

La soluzione è utilizzare librerie specializzate:

• curl-impersonate (Python) — imita il fingerprint TLS di Chrome/Firefox
• tls-client (Go, binding Python) — fingerprint TLS configurabile
• Playwright / Puppeteer — browser headless con vero TLS

Per la maggior parte delle attività di parsing dei marketplace, sono sufficienti intestazioni HTTP corrette e proxy residenziali. Il fingerprinting TLS è critico solo quando si lavora con le API più protette.

API vs web scraping: quale è più sicuro per il parsing

I marketplace hanno due modi per ottenere dati: API ufficiali e parsing delle pagine HTML (web scraping). Quale scegliere per un funzionamento stabile?

Raccomandazioni per la scelta:

• Utilizza l'API ufficiale se: Hai bisogno di piccoli volumi di dati (fino a 10.000 prodotti al giorno), sei disposto a pagare per l'accesso, la legalità e la stabilità sono importanti.
• Utilizza il web scraping se: Hai bisogno di grandi volumi di dati, l'API ufficiale non fornisce le informazioni necessarie (ad esempio, i prezzi dei concorrenti), il budget è limitato.

Approccio ibrido: Molti parser professionali combinano entrambi i metodi. Ad esempio, ottengono un elenco di prodotti tramite API (velocemente e legalmente), mentre le informazioni dettagliate sui prezzi e le giacenze vengono estratte dalle pagine HTML (più dati).

API interne dei marketplace: Oltre all'API ufficiale, i marketplace utilizzano API interne per il funzionamento del sito. Ad esempio, Wildberries carica i dati dei prodotti tramite https://card.wb.ru/cards/detail. Questi endpoint non sono documentati, ma funzionano più velocemente del parsing HTML. Il contro è che possono cambiare senza preavviso.

Configurazione dei parser e degli strumenti più popolari

La maggior parte dei venditori e dei marketer utilizza strumenti pronti per il parsing dei marketplace. Vediamo come configurare correttamente i proxy e i limiti nelle soluzioni più popolari.

Configurazione di Scrapy (framework Python)

Scrapy è un framework popolare per il web scraping. Per lavorare con i marketplace, aggiungi a settings.py:

# Ritardi tra le richieste
DOWNLOAD_DELAY = 3  # 3 secondi
RANDOMIZE_DOWNLOAD_DELAY = True  # Randomizzazione da 0.5*DELAY a 1.5*DELAY

# Limiti delle richieste simultanee
CONCURRENT_REQUESTS = 8
CONCURRENT_REQUESTS_PER_DOMAIN = 2

# Configurazione dei proxy (tramite middleware rotating-proxies)
ROTATING_PROXY_LIST = [
    'http://user:pass@proxy1.example.com:8000',
    'http://user:pass@proxy2.example.com:8000',
    # ... lista di proxy
]

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

# Tentativi ripetuti in caso di errori
RETRY_TIMES = 3
RETRY_HTTP_CODES = [429, 500, 502, 503, 504]

Configurazione di Octoparse (parser visivo senza codice)

Octoparse è uno strumento popolare per il parsing senza programmazione. Configurazione dei proxy e dei limiti:

1. Apri Impostazioni Task → Opzioni Avanzate
2. Nella sezione "Network" attiva "Usa server proxy"
3. Aggiungi l'elenco dei proxy nel formato IP:PORT:USER:PASS
4. Attiva "Ruota IP per ogni richiesta" per rotazione automatica
5. Nella sezione "Speed" imposta "Slow" o "Custom" con un ritardo di 3-5 secondi
6. Attiva "Ritardo casuale" per imitare il comportamento umano

Configurazione di Selenium (automazione del browser)

Selenium gestisce un vero browser, quindi bypassa molte protezioni. Ecco un esempio di configurazione con proxy:

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

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

driver = webdriver.Chrome(options=chrome_options)

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

# Parsing con ritardi
urls = ['https://www.wildberries.ru/catalog/...', ...]

for url in urls:
    driver.get(url)
    # Ritardo casuale di 3-7 secondi
    time.sleep(random.uniform(3, 7))
    
    # Scorrimento per imitare la lettura
    driver.execute_script("window.scrollTo(0, document.body.scrollHeight/2);")
    time.sleep(random.uniform(1, 3))
    
    # Parsing dei dati
    # ...

Servizi di parsing dei marketplace già pronti

Se non vuoi configurare il parser da solo, utilizza servizi specializzati:

• Mpstats.io — analisi di Wildberries e Ozon, monitoraggio automatico dei prezzi e delle vendite
• SellerFox — monitoraggio dei concorrenti sui marketplace, tracciamento delle giacenze
• Moneyplace — parsing di Avito, pubblicazione automatica degli annunci
• Parsehub — parser visivo per qualsiasi sito, inclusi i marketplace

Questi servizi hanno già configurato proxy, limiti e bypass delle protezioni — ti resta solo da indicare cosa fare il parsing. Contro: abbonamento mensile a partire da 2000₽.

Monitoraggio dei blocchi e reazione automatica

Anche con le impostazioni corrette, i blocchi sono possibili: i marketplace aggiornano le protezioni, i proxy finiscono nelle blacklist, i limiti cambiano. È importante monitorare i problemi e reagire automaticamente.

Segnali di blocco da monitorare:

• HTTP 429 (Troppe Richieste) — superato il limite delle richieste, necessaria pausa o cambio IP
• HTTP 403 (Vietato) — IP bloccato, necessaria rotazione immediata dei proxy
• HTTP 503 (Servizio Non Disponibile) — sovraccarico temporaneo o protezione DDoS
• Captcha nella risposta — rilevata automazione, necessario ridurre l'attività
• Risposte vuote o reindirizzamento alla homepage — blocco soft
• Aumento improvviso del tempo di risposta — possibile limitazione della velocità lato server

Reazione automatica ai blocchi (esempio in Python):

import requests
import time
from datetime import datetime

class SmartParser:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
        self.current_proxy_index = 0
        self.request_count = 0
        self.blocked_proxies = set()
        
    def get_next_proxy(self):
        # Salta i proxy bloccati
        while self.current_proxy_index in self.blocked_proxies:
            self.current_proxy_index = (self.current_proxy_index + 1) % len(self.proxy_list)
        
        proxy = self.proxy_list[self.current_proxy_index]
        return {'http': proxy, 'https': proxy}
    
    def rotate_proxy(self):
        self.current_proxy_index = (self.current_proxy_index + 1) % len(self.proxy_list)
        self.request_count = 0
        
    def make_request(self, url):
        max_retries = 3
        
        for attempt in range(max_retries):
            try:
                proxy = self.get_next_proxy()
                response = requests.get(url, proxies=proxy, timeout=10)
                
                # Controllo del blocco
                if response.status_code == 429:
                    print(f"[{datetime.now()}] Limite di velocità! Pausa di 60 secondi...")
                    time.sleep(60)
                    self.rotate_proxy()
                    continue
                    
                elif response.status_code == 403:
                    print(f"[{datetime.now()}] IP bloccato! Rotazione del proxy...")
                    self.blocked_proxies.add(self.current_proxy_index)
                    self.rotate_proxy()
                    continue
                    
                elif response.status_code == 503:
                    print(f"[{datetime.now()}] Server sovraccarico. Pausa di 120 secondi...")
                    time.sleep(120)
                    continue
                
                # Richiesta riuscita
                self.request_count += 1
                
                # Rotazione dopo 200 richieste
                if self.request_count >= 200:
                    self.rotate_proxy()
                    time.sleep(10)  # Pausa dopo la rotazione
                
                return response
                
            except requests.exceptions.Timeout:
                print(f"[{datetime.now()}] Timeout. Tentativo {attempt + 1}/{max_retries}")
                time.sleep(5)
                
        return None  # Tutti i tentativi esauriti

Logging e avvisi: Imposta notifiche per eventi critici. Ad esempio, invia un messaggio su Telegram quando:

• Bloccato più del 30% dei proxy dal pool
• Percentuale di richieste riuscite scesa sotto l'80%
• Il parser non ha ricevuto dati per più di 30 minuti
• Rilevata captcha nelle risposte

Metriche da monitorare:

Utilizza dashboard per visualizzare le metriche: Grafana, Datadog o semplici Google Sheets con aggiornamento automatico tramite API.

Conclusione

I blocchi durante il parsing dei marketplace non sono un ostacolo, ma un compito che può essere risolto con la giusta configurazione degli strumenti. I punti chiave per un funzionamento stabile senza ban:

• Utilizza proxy residenziali per Wildberries, Ozon e Avito — i proxy dei data center qui non funzionano
• Configura ritardi randomizzati di 2-5 secondi tra le richieste
• Ruota gli IP dopo ogni 150-300 richieste o ogni 30-60 minuti
• Utilizza intestazioni HTTP realistiche con User-Agent attuali
• Monitora i blocchi e reagisci automaticamente a essi
• Per Avito è obbligatoria la geolocalizzazione dell'IP rispetto alla città dell'annuncio

Un parser correttamente configurato con proxy di qualità può funzionare per mesi senza un singolo blocco, raccogliendo decine di migliaia di prodotti ogni giorno. L'importante è non inseguire la velocità, ma imitare il comportamento di un normale utente.

Se prevedi di fare parsing regolarmente di Wildberries, Ozon o Avito, ti consigliamo di utilizzare proxy residenziali con rotazione automatica — garantiscono la massima stabilità e il minimo rischio di blocchi. Per attività che richiedono IP mobili (ad esempio, bypass dei blocchi severi di Avito) sono adatti proxy mobili con IP di operatori russi.