Comment éviter le blocage lors de requêtes fréquentes à l'API de Wildberries, Ozon et Avito

Si vous surveillez les prix des concurrents, scrapez les stocks de produits ou publiez automatiquement des annonces sur les marketplaces, vous avez sûrement rencontré des blocages. L'API de Wildberries, Ozon, Yandex.Market et Avito se protègent activement contre l'automatisation : elles limitent le nombre de requêtes, bloquent les adresses IP et exigent des captchas. Dans ce guide, nous examinerons pourquoi les blocages se produisent et comment configurer un scraper pour fonctionner de manière stable pendant des mois sans bans.

Pourquoi les marketplaces bloquent les requêtes fréquentes à l'API

Les marketplaces dépensent d'énormes sommes d'argent pour maintenir leur infrastructure — serveurs, bases de données, CDN. Lorsque vous effectuez des milliers de requêtes par minute pour scraper les prix, vous créez une charge supplémentaire sur leurs systèmes. Mais la principale raison des blocages n'est pas technique, mais orientée vers les affaires.

Principales raisons des blocages :

• Protection des données concurrentielles. Wildberries et Ozon ne veulent pas que les concurrents obtiennent facilement des informations sur les prix, les stocks et les produits populaires. Ces données sont un secret commercial.
• Réduction de la charge sur les serveurs. Un scraper peut générer autant de requêtes que 10 000 acheteurs ordinaires. Cela augmente les coûts d'hébergement.
• Lutte contre la manipulation et le spam. Les systèmes automatisés sont utilisés pour manipuler les vues, les avis, et pour publier massivement des annonces sur Avito.
• Monétisation de l'API. Certaines marketplaces proposent des API payantes officielles avec des limites. En bloquant le scraping gratuit, elles incitent à acheter l'accès.

Par exemple, si vous surveillez les prix de 5000 produits chaque heure, cela représente 120 000 requêtes par jour. Depuis une seule adresse IP, cela semble suspect, et le système de protection de la marketplace bloquera rapidement votre accès.

Quelles méthodes de protection utilisent Wildberries, Ozon et Avito

Les marketplaces modernes utilisent une protection multi-niveaux contre le scraping. Comprendre ces mécanismes aidera à configurer correctement le contournement des blocages.

Wildberries utilise une protection agressive : limite d'environ 200-300 requêtes par heure depuis une IP, vérification du User-Agent et défis JavaScript. Si vous dépassez la limite, vous recevrez un HTTP 429 (Trop de Requêtes) ou 403 (Interdit).

Ozon est plus tolérant au scraping via l'API, mais bloque activement les IP des centres de données. Ils utilisent des services de détection du type d'IP (DataCenter vs Résidentiel), donc les proxies ordinaires fonctionnent souvent mal.

Avito protège l'API contre la publication massive d'annonces et le scraping des contacts. Ici, la géolocalisation est importante : si vous publiez une annonce à Kazan, l'IP doit être de Kazan, sinon la modération bloquera la publication.

Limitation de débit : comment configurer correctement les délais entre les requêtes

La limitation de débit est une restriction artificielle de la vitesse des requêtes, afin que votre activité ressemble à celle d'un utilisateur ordinaire. La règle principale : mieux vaut lentement mais sûrement que rapidement et avec un ban.

Paramètres recommandés pour les marketplaces populaires :

Comment réaliser des délais randomisés : N'utilisez pas d'intervalles fixes comme "exactement 3 secondes" — cela ressemble à un bot. Ajoutez de la randomisation : entre 2 et 5 secondes. La plupart des scrapers prennent en charge cela via les paramètres.

Par exemple, en Python avec la bibliothèque requests, cela ressemble à ceci :

import time
import random
import requests

def make_request(url, proxies):
    response = requests.get(url, proxies=proxies)
    # Délai randomisé entre 2 et 5 secondes
    delay = random.uniform(2.0, 5.0)
    time.sleep(delay)
    return response

# Exemple d'utilisation
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)
    # Traitement des données...

Point important : Après chaque 100-200 requêtes, faites une longue pause (10-20 minutes) ou changez d'IP. Cela imite le comportement d'un humain qui consulte des produits, puis se distrait avec d'autres tâches.

Rotation des proxies pour répartir la charge

Même avec des délais corrects, une seule IP ne supportera pas une charge prolongée. La solution est la rotation des proxies : répartir les requêtes entre de nombreuses adresses IP. C'est la base d'un scraping stable des marketplaces.

Types de proxies pour le scraping des marketplaces :

Pour le scraping de Wildberries et Ozon, nous recommandons d'utiliser des proxies résidentiels — ils ont des IP de véritables utilisateurs domestiques, donc les marketplaces ne peuvent pas les distinguer des acheteurs ordinaires. Les proxies de centres de données fonctionnent mal ici : Ozon et Wildberries tiennent des listes noires de telles IP.

Stratégies de rotation des proxies :

• Rotation après N requêtes. Changez d'IP après chaque 100-300 requêtes. C'est un équilibre optimal entre efficacité et sécurité.
• Rotation par temps. Changez d'IP toutes les 30-60 minutes. Convient pour de longues sessions de scraping.
• Sessions collantes. Utilisez une IP pour toutes les requêtes à un produit/catégorie, puis changez. Cela réduit la suspicion.
• Géolocalisation. Pour Avito, c'est obligatoire : scrapez les annonces de Moscou via des IP moscovites, celles de Kazan via des IP kazaniennes.

La plupart des fournisseurs de proxies résidentiels proposent une rotation automatique : vous obtenez un seul point d'accès, et l'IP change automatiquement à une fréquence définie ou après chaque requête. Cela simplifie la configuration du scraper.

Exemple de configuration d'un pool de proxies en Python :

import requests
import random

# Liste de proxies (peut être chargée depuis un fichier)
proxy_list = [
    'http://user:pass@proxy1.example.com:8000',
    'http://user:pass@proxy2.example.com:8000',
    'http://user:pass@proxy3.example.com:8000',
    # ... encore 50-100 proxies
]

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

# Utilisation
for product_id in product_list:
    proxy = get_random_proxy()  # Proxy aléatoire pour chaque requête
    response = requests.get(url, proxies=proxy)
    # Traitement...

Configuration des en-têtes et fingerprint pour imiter un navigateur

Les marketplaces analysent non seulement les IP et la fréquence des requêtes, mais aussi les en-têtes HTTP. Si votre scraper envoie des requêtes avec les en-têtes par défaut de la bibliothèque (par exemple, python-requests/2.28.0), il sera immédiatement identifié comme un bot.

En-têtes obligatoires pour imiter un navigateur :

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': 'fr-FR,fr;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/'
}

Points importants :

• User-Agent doit correspondre à un véritable navigateur. Utilisez des versions actuelles de Chrome, Firefox, Safari. Changez le User-Agent toutes les 100-200 requêtes.
• Accept-Language doit correspondre à la géographie du proxy. Si vous utilisez des IP russes, mettez ru-RU, pour les ukrainiennes — uk-UA.
• Referer montre d'où vient l'utilisateur. Pour la première requête, utilisez Google/Yandex, pour les suivantes — des pages internes de la marketplace.
• Les en-têtes Sec-Fetch-* ajoutent du réalisme. Les navigateurs modernes les envoient automatiquement.

Fingerprinting TLS : Les systèmes de protection avancés (Ozon, Wildberries) analysent les paramètres de la connexion TLS : l'ordre des suites de chiffrement, les extensions, la version du protocole. Les bibliothèques standards Python/Node.js ont un fingerprint différent de celui des navigateurs.

La solution est d'utiliser des bibliothèques spécialisées :

• curl-impersonate (Python) — imite le fingerprint TLS de Chrome/Firefox
• tls-client (Go, liaisons Python) — fingerprint TLS configurable
• Playwright / Puppeteer — navigateurs headless avec un véritable TLS

Pour la plupart des tâches de scraping des marketplaces, des en-têtes HTTP corrects et des proxies résidentiels suffisent. Le fingerprinting TLS est critique uniquement lors de l'utilisation des API les plus sécurisées.

API vs web scraping : ce qui est plus sûr pour le scraping

Les marketplaces ont deux façons d'obtenir des données : API officielle et scraping des pages HTML (web scraping). Lequel choisir pour un fonctionnement stable ?

Recommandations pour le choix :

• Utilisez l'API officielle si : Vous avez besoin de petites quantités de données (jusqu'à 10 000 produits par jour), vous êtes prêt à payer pour l'accès, la légalité et la stabilité sont importantes.
• Utilisez le web scraping si : Vous avez besoin de grandes quantités de données, l'API officielle ne fournit pas les informations nécessaires (par exemple, les prix des concurrents), le budget est limité.

Approche hybride : De nombreux scrapers professionnels combinent les deux méthodes. Par exemple, ils obtiennent une liste de produits via l'API (rapidement et légalement), puis scrappent les informations détaillées sur les prix et les stocks à partir des pages HTML (plus de données).

API internes des marketplaces : En plus de l'API officielle, les marketplaces utilisent des API internes pour le fonctionnement du site. Par exemple, Wildberries charge les données des produits via https://card.wb.ru/cards/detail. Ces points de terminaison ne sont pas documentés, mais fonctionnent plus rapidement que le scraping HTML. Inconvénient — ils peuvent changer sans préavis.

Configuration des scrapers et outils populaires

La plupart des vendeurs et des marketeurs utilisent des outils prêts à l'emploi pour le scraping des marketplaces. Voyons comment configurer correctement les proxies et les limites dans des solutions populaires.

Configuration de Scrapy (framework Python)

Scrapy est un framework populaire pour le web scraping. Pour travailler avec les marketplaces, ajoutez dans settings.py :

# Délais entre les requêtes
DOWNLOAD_DELAY = 3  # 3 secondes
RANDOMIZE_DOWNLOAD_DELAY = True  # Randomisation de 0.5*DELAY à 1.5*DELAY

# Limites des requêtes simultanées
CONCURRENT_REQUESTS = 8
CONCURRENT_REQUESTS_PER_DOMAIN = 2

# Configuration des proxies (via middleware rotating-proxies)
ROTATING_PROXY_LIST = [
    'http://user:pass@proxy1.example.com:8000',
    'http://user:pass@proxy2.example.com:8000',
    # ... liste de proxies
]

# Rotation du 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',
    # ... liste de User-Agent
]

# Tentatives de réessai en cas d'erreurs
RETRY_TIMES = 3
RETRY_HTTP_CODES = [429, 500, 502, 503, 504]

Configuration d'Octoparse (scraper visuel sans code)

Octoparse est un outil populaire pour le scraping sans programmation. Configuration des proxies et des limites :

1. Ouvrez les paramètres de la tâche → Options avancées
2. Dans la section "Réseau", activez "Utiliser un serveur proxy"
3. Ajoutez la liste des proxies au format IP:PORT:USER:PASS
4. Activez "Rotation d'IP pour chaque requête" pour une rotation automatique
5. Dans la section "Vitesse", définissez "Lent" ou "Personnalisé" avec un délai de 3-5 secondes
6. Activez "Délai aléatoire" pour imiter le comportement humain

Configuration de Selenium (automatisation du navigateur)

Selenium contrôle un véritable navigateur, donc contourne de nombreuses protections. Exemple de configuration avec un proxy :

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

# Configuration de Chrome avec un 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)

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

# Scraping avec des délais
urls = ['https://www.wildberries.ru/catalog/...', ...]

for url in urls:
    driver.get(url)
    # Délai aléatoire de 3-7 secondes
    time.sleep(random.uniform(3, 7))
    
    # Défilement pour imiter la lecture
    driver.execute_script("window.scrollTo(0, document.body.scrollHeight/2);")
    time.sleep(random.uniform(1, 3))
    
    # Scraping des données
    # ...

Services de scraping des marketplaces

Si vous ne souhaitez pas configurer le scraper vous-même, utilisez des services spécialisés :

• Mpstats.io — analyse de Wildberries et Ozon, surveillance automatique des prix et des ventes
• SellerFox — surveillance des concurrents sur les marketplaces, suivi des stocks
• Moneyplace — scraping d'Avito, publication automatique d'annonces
• Parsehub — scraper visuel pour tous les sites, y compris les marketplaces

Ces services ont déjà configuré les proxies, les limites et le contournement des protections — il ne vous reste plus qu'à indiquer ce que vous souhaitez scraper. Inconvénient — abonnement mensuel à partir de 2000₽.

Surveillance des blocages et réaction automatique

Même avec des réglages corrects, des blocages peuvent survenir : les marketplaces mettent à jour leur protection, les proxies se retrouvent sur des listes noires, les limites changent. Il est important de surveiller les problèmes et de réagir automatiquement.

Signes de blocage à surveiller :

• HTTP 429 (Trop de Requêtes) — limite de requêtes dépassée, besoin d'une pause ou de changer d'IP
• HTTP 403 (Interdit) — IP bloquée, besoin d'une rotation immédiate des proxies
• HTTP 503 (Service Indisponible) — surcharge temporaire ou protection contre DDoS
• Captcha dans la réponse — automatisation détectée, besoin de réduire l'activité
• Réponses vides ou redirection vers la page d'accueil — blocage léger
• Augmentation soudaine du temps de réponse — possible limitation de débit côté serveur

Réaction automatique aux blocages (exemple en 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):
        # Ignorer les proxies bloqués
        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)
                
                # Vérification de blocage
                if response.status_code == 429:
                    print(f"[{datetime.now()}] Limite de débit ! Pause de 60 secondes...")
                    time.sleep(60)
                    self.rotate_proxy()
                    continue
                    
                elif response.status_code == 403:
                    print(f"[{datetime.now()}] IP bloquée ! Rotation des proxies...")
                    self.blocked_proxies.add(self.current_proxy_index)
                    self.rotate_proxy()
                    continue
                    
                elif response.status_code == 503:
                    print(f"[{datetime.now()}] Serveur surchargé. Pause de 120 secondes...")
                    time.sleep(120)
                    continue
                
                # Requête réussie
                self.request_count += 1
                
                # Rotation après 200 requêtes
                if self.request_count >= 200:
                    self.rotate_proxy()
                    time.sleep(10)  # Pause après rotation
                
                return response
                
            except requests.exceptions.Timeout:
                print(f"[{datetime.now()}] Délai d'attente. Tentative {attempt + 1}/{max_retries}")
                time.sleep(5)
                
        return None  # Toutes les tentatives épuisées

Journalisation et alertes : Configurez des notifications pour les événements critiques. Par exemple, envoyez un message sur Telegram lorsque :

• Plus de 30 % des proxies du pool sont bloqués
• Le pourcentage de requêtes réussies est tombé en dessous de 80 %
• Le scraper n'a pas reçu de données pendant plus de 30 minutes
• Un captcha a été détecté dans les réponses

Métriques à surveiller :

Utilisez des tableaux de bord pour visualiser les métriques : Grafana, Datadog ou des Google Sheets simples avec mise à jour automatique via API.

Conclusion

Les blocages lors du scraping des marketplaces ne sont pas un obstacle, mais une tâche que l'on peut résoudre par une configuration appropriée des outils. Points clés pour un fonctionnement stable sans bans :

• Utilisez des proxies résidentiels pour Wildberries, Ozon et Avito — les proxies de centres de données ne fonctionnent pas ici
• Configurez des délais randomisés de 2-5 secondes entre les requêtes
• Rotez les IP après chaque 150-300 requêtes ou toutes les 30-60 minutes
• Utilisez des en-têtes HTTP réalistes avec des User-Agent actuels
• Surveillez les blocages et réagissez automatiquement
• Pour Avito, la géolocalisation de l'IP à la ville de l'annonce est obligatoire

Un scraper correctement configuré avec des proxies de qualité peut fonctionner pendant des mois sans un seul blocage, collectant des dizaines de milliers de produits quotidiennement. L'essentiel est de ne pas courir après la vitesse, mais d'imiter le comportement d'un utilisateur ordinaire.

Si vous prévoyez de scraper régulièrement Wildberries, Ozon ou Avito, nous vous recommandons d'utiliser des proxies résidentiels avec rotation automatique — ils offrent une stabilité maximale et un risque minimal de blocages. Pour les tâches nécessitant des IP mobiles (par exemple, contourner les blocages stricts d'Avito), des proxies mobiles avec des IP d'opérateurs russes conviendront.