Scraping web sans être bloqué : 12 techniques éprouvées

Les bots représentent désormais 51 % du trafic web. Les sites web le savent et ripostent. Les systèmes anti-bots de Cloudflare, Akamai et DataDome combinent désormais la réputation IP, l’empreinte TLS, l’empreinte du navigateur et l’analyse comportementale pour bloquer les Scrapers avant qu’une seule ligne de code HTML ne soit renvoyée. Si votre Scraper continue d’être bloqué, ce guide vous explique exactement pourquoi et vous propose 12 techniques spécifiques pour y remédier.

Résumé rapide : comment scraper sans être bloqué

• Faites tourner les adresses IP à l’aide de proxys résidentiels. Les adresses IP des centres de données sont facilement repérables.
• Définissez des en-têtes HTTP complets, similaires à ceux d’un navigateur, y compris User-Agent et Referer.
• Randomisez le timing des requêtes avec des délais variables entre 2 et 10 secondes.
• Utilisez un navigateur sans interface graphique avec des plugins furtifs pour passer les contrôles d’empreintes digitales.
• Traitez automatiquement les CAPTCHA, car la résolution manuelle n’est pas évolutive.
• Faites correspondre la géolocalisation du Proxy à la base d’utilisateurs attendue du site cible.
• Utilisez une API de scraping gérée (comme Web Unlocker de Bright Data) pour automatiser toutes les étapes ci-dessus.

Pourquoi les sites web bloquent-ils les Scrapers ?

Comprendre pourquoi vous êtes bloqué est la première étape pour éviter d’être bloqué. La détection ne se produit pas après le téléchargement d’une page. Elle se produit souvent dans les premières millisecondes de la connexion, avant que le code HTML ne soit servi. Les techniques anti-scraping les plus courantes fonctionnent en combinaison par couches — et pour les contourner, il faut faire correspondre toutes les couches simultanément.

Détection basée sur l’adresse IP

Chaque requête que vous effectuez comporte une adresse IP source. Les systèmes anti-bot gèrent des bases de données de réputation des plages d’adresses IP connues des centres de données (AWS, GCP, Azure, DigitalOcean), des adresses IP précédemment signalées et des adresses IP présentant un volume de requêtes élevé. Une seule adresse IP envoyant 500 requêtes par minute est facilement identifiée. Les adresses IP des centres de données sont signalées par défaut sur de nombreux sites hautement sécurisés, car aucun utilisateur résidentiel réel ne se connecte à partir d’un centre de données AWS.

Empreinte digitale du navigateur et TLS

Chaque connexion HTTPS commence par une poignée de main TLS. Pendant la phase ClientHello, votre client diffuse ses suites de chiffrement prises en charge, sa version TLS, ses extensions et ses préférences en matière de courbes elliptiques, le tout en texte clair, avant que tout contenu ne soit échangé. Les systèmes anti-bot hachent ces données pour obtenir une empreinte digitale (norme JA3 ou JA4) et la comparent aux signatures de bots connus. La bibliothèque de requêtes Python possède une empreinte digitale TLS distinctive qui diffère de celle de tout navigateur réel et qui est facilement détectée par Cloudflare et Akamai.

Au-delà du TLS, les sites web détectent votre type de navigateur grâce à des dizaines de signaux JavaScript : navigator.webdriver, rendu canvas, chaînes GPU WebGL, polices installées, résolution d’écran, comportement du contexte audio et listes de plugins. Headless Chrome expose HeadlessChrome dans sa chaîne User-Agent et laisse navigator.webdriver = true défini, ce qui constitue un signal de détection immédiat sur la plupart des principales plateformes anti-bot.

Analyse comportementale

Les sites web ne se contentent pas d’examiner les requêtes individuelles. Ils observent les schémas tout au long d’une session. PerimeterX/HUMAN et les systèmes similaires mesurent le temps entre les requêtes, les schémas de défilement, les trajectoires des mouvements de la souris, le comportement des clics, la profondeur de navigation et la durée de la session. Un Scraper qui envoie des requêtes à des intervalles exacts de 1,0 seconde, ne fait jamais défiler, ne déplace jamais la souris et passe directement aux pages profondes du produit sans visiter la page d’accueil, se distingue immédiatement d’un humain.

CAPTCHAs et défis JavaScript

Lorsqu’un site soupçonne une automatisation mais n’en est pas certain, il lance un défi. Cloudflare Turnstile, reCAPTCHA v3 et hCaptcha exécutent des sondes JavaScript qui vérifient la présence d’artefacts d’automatisation. Si ces défis échouent ou si JavaScript n’est pas exécuté, cela entraîne un blocage ou une boucle de redirection infinie.

Pièges Honeypot

Certains sites injectent des liens cachés dans leur code HTML, invisibles pour les utilisateurs réels via CSS (display: none), mais entièrement accessibles aux Scrapers qui effectuent l’analyse du code HTML brut. Suivre ces liens vous identifie instantanément comme un bot. Un Scraper qui suit aveuglément chaque balise <A href> dans un document finira par tomber dessus.

Les meilleures techniques pour scraper des sites web sans être bloqué

1. Faites tourner vos adresses IP avec des proxys

La rotation des adresses IP est la technique anti-détection la plus fondamentale. Au lieu d’envoyer toutes les requêtes à partir d’une seule adresse IP, un Pool de proxies répartit le trafic sur des centaines ou des milliers d’adresses IP afin qu’aucune adresse IP ne cumule un volume de requêtes suspect. Apprendre à faire tourner les proxys en Python est une compétence essentielle pour toute personne qui souhaite créer un Scraper performant.

Le modèle de base : acheminer chaque requête via un point de terminaison Proxy différent et mettre en œuvre une logique de réessai automatique lorsqu’une adresse IP est bloquée.

import requests
from itertools import cycle
import random
import time

proxies = [
    "http://proxy1.example.com:8080",
    "http://proxy2.example.com:8080",
    "http://proxy3.example.com:8080",
]

proxy_pool = cycle(proxies)

def fetch(url):
    proxy = next(proxy_pool)
    try:
        response = requests.get(
            url,
            proxies={"http": proxy, "https": proxy},
            timeout=10
        )
        response.raise_for_status()
        return response.text
    except requests.exceptions.RequestException as e:
        print(f"Proxy {Proxy} failed: {e}")
        return None

# Ajouter un délai aléatoire entre les requêtes pour éviter la limitation du débit
time.sleep(random.uniform(2, 6))

Une opération à haut volume nécessite plus qu’une simple rotation round-robin. Elle nécessite une gestion intelligente des sessions, une mise hors service automatique des adresses IP et une sélection géolocalisée. C’est pourquoi les Scrapers de production utilisent une infrastructure de Proxys gérée plutôt qu’une liste statique.

2. Utilisez des Proxys résidentiels ou mobiles

Tous les proxys ne sont pas égaux. Les proxys de centre de données et les proxys résidentiels représentent un compromis fondamental entre le coût et le risque de détection. Les proxys de centre de données acheminent le trafic via les adresses IP des serveurs cloud : ils sont rapides, bon marché, mais immédiatement identifiables comme non humains par tout système anti-bot disposant d’une liste noire ASN.

Les proxys résidentiels acheminent le trafic via de véritables adresses IP attribuées par les FAI et liées à des connexions domestiques et professionnelles réelles. Pour un site cible, la requête semble provenir d’un utilisateur réel dans une ville spécifique sur un FAI spécifique. Les proxys mobiles vont plus loin en acheminant le trafic via de véritables adresses IP d’opérateurs mobiles (4G/5G), qui sont encore moins susceptibles d’être mises sur liste noire car les opérateurs utilisent le CGNAT (une seule adresse IP partagée par de nombreux utilisateurs réels).

Bright Data exploite un réseau de plus de 150 millions d’IPs résidentielles dans plus de 195 pays, le plus grand réseau de Proxys éthiques disponible. Dans les cas où même les IPs résidentielles sont signalées, plus de 7 millions d’IPs mobiles fournissent le signal de confiance le plus élevé possible.

3. Définir des en-têtes de requête réalistes

La bibliothèque de requêtes Python envoie par défaut un ensemble minimal d’en-têtes. Par rapport à un véritable navigateur Chrome, la différence est immédiatement évidente :

# Ce que requests envoie par défaut :
User-Agent: python-requests/2.31.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive

# Ce que Chrome 121 envoie réellement :
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8
Accept-Language : en-US,en ; q=0.9
Accept-Encoding : gzip, deflate, br, zstd
Connection : keep-alive
Upgrade-Insecure-Requests : 1
Sec-Fetch-Dest : document
Sec-Fetch-Mode : navigate
Sec-Fetch-Site : none
Sec-Fetch-User : ?1

Les sites vérifient les en-têtes Accept, Accept-Language, Accept-Encoding, Sec-Fetch-* et l’ordre des en-têtes afin de distinguer les navigateurs réels des scripts. Définissez des en-têtes qui correspondent au navigateur que vous prétendez utiliser, y compris l’en-tête Referer lorsque vous naviguez entre des pages du même domaine. Pour plus d’informations, consultez notre guide sur les en-têtes HTTP pour le Scraping web.

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9",
    « Accept-Encoding » : « gzip, deflate, br »,
    « Referer » : « https://www.google.com/ »,
    « Sec-Fetch-Dest » : « document »,
    « Sec-Fetch-Mode » : « navigate »,
    « Sec-Fetch-Site » : « cross-site »,
    « Upgrade-Insecure-Requests » : « 1 »,
}

response = requests.get(url, headers=headers)

4. Alterner les agents utilisateurs

Envoyer la même chaîne User-Agent à chaque requête est un autre indicateur facile à repérer. Les utilisateurs réels n’utilisent pas tous Chrome 121 sous Windows 10. Créez un ensemble de chaînes User-Agent réalistes et récemment actives, puis faites-les tourner. Règle essentielle : le User-Agent vers lequel vous effectuez la rotation doit être cohérent en interne. Si vous prétendez être Chrome sur macOS, vos en-têtes Accept-Language et Sec-CH-UA doivent refléter cela.

import random

user_agents = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (X11; Linux x86_64; rv:122.0) Gecko/20100101 Firefox/122.0",
    « Mozilla/5.0 (iPhone ; CPU iPhone OS 17_2 comme Mac OS X) AppleWebKit/605.1.15 (KHTML, comme Gecko) Version/17.2 Mobile/15E148 Safari/604.1 »,
]

headers["User-Agent"] = random.choice(user_agents)

Maintenez votre pool d’agents utilisateurs à jour. Les versions de navigateur de 2021 constituent en elles-mêmes un signal de détection, car elles sont statistiquement peu susceptibles de représenter le trafic réel en 2026.

5. Gérez les empreintes TLS

Il s’agit de la technique la plus souvent négligée et celle qui permet de déjouer les Scrapers qui ont tout fait correctement.

Lorsque la bibliothèque de requêtes Python initie une connexion HTTPS, la pile TLS sous-jacente (OpenSSL ou similaire) envoie un ClientHello avec une combinaison spécifique de suites de chiffrement et d’extensions. Cette combinaison est hachée en une valeur JA3 qui n’est clairement pas celle d’un navigateur. Cloudflare, Akamai et DataDome vérifient cette empreinte avant de servir tout contenu, vous pouvez donc être bloqué avant même que vos en-têtes ne soient évalués.

La solution : utiliser un client HTTP qui imite la pile TLS d’un vrai navigateur. curl_cffi est la norme actuelle pour Python :

from curl_cffi import requests as curl_requests

# impersonate="chrome121" indique à curl_cffi d'utiliser exactement les suites de chiffrement TLS, les extensions et les paramètres HTTP/2 de Chrome 121.
# TLS cipher suites, extensions, and HTTP/2 settings
response = curl_requests.get(
    "https://example.com",
    impersonate="chrome121",
    headers={
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ...",
    })


print(response.status_code)

curl_cffi encapsule curl-impersonate, une version de libcurl qui imite les empreintes TLS réelles des navigateurs au niveau cryptographique. Exigence essentielle : votre User-Agent doit correspondre au profil du navigateur que vous imitez. L’envoi d’une empreinte TLS Chrome 121 avec un User-Agent Firefox crée une incohérence que les systèmes avancés détectent.

Pour une utilisation à l’échelle de la production, Web Unlocker de Bright Data gère automatiquement la correspondance des empreintes TLS sans nécessiter de gestion de bibliothèque.

6. Utilisez un navigateur sans interface graphique avec des plugins furtifs

Lorsque le site cible exécute des défis JavaScript, vous avez besoin d’un véritable navigateur. Comprendre ce qu’est un navigateur sans interface graphique et comment il fonctionne vous donne les bases nécessaires pour utiliser cette technique. Playwright et Puppeteer automatisent Chromium, permettant l’exécution complète de JavaScript, la gestion des cookies et le rendu dynamique du contenu.

Le problème : Chrome sans interface utilisateur par défaut est facilement détecté. Il expose navigator.webdriver = true, une chaîne User-Agent HeadlessChrome, des plugins de navigateur manquants et des dimensions d’écran anormales. Turnstile de Cloudflare et les systèmes similaires exécutent plus de 200 vérifications JavaScript et détectent une session Playwright par défaut en quelques millisecondes.

La solution est playwright-stealth, un plugin qui corrige ces vecteurs de détection :

from playwright.sync_api import sync_playwright
from playwright_stealth import stealth_sync

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()

    # Corrige navigator.webdriver, chrome runtime, les fenêtres de contenu iframe,
    # les codecs multimédias et d'autres artefacts d'automatisation.
    stealth_sync(page)

    page.goto("https://example.com")
    print(page.title())
    browser.close()

playwright-stealth gère les vecteurs de détection les plus courants : navigator.webdriver, window.chrome, navigator.plugins, navigator.languages et les incohérences de l’API des autorisations. Pour les utilisateurs de Selenium, undetected-chromedriver est l’équivalent, corrigeant ChromeDriver au niveau binaire.

Limitation importante : les plugins furtifs réduisent le risque de détection, mais ne l’éliminent pas. Cloudflare Turnstile et Akamai Bot Manager ont considérablement évolué et peuvent toujours détecter les navigateurs headless corrigés. Pour une fiabilité maximale, le Navigateur de scraping de Bright Data est un environnement de navigation pré-renforcé, spécialement conçu pour passer ces contrôles dès son installation, sans aucune configuration de plugin.

7. Randomiser le timing et le comportement des requêtes

Les Scrapers qui envoient des requêtes à intervalles fixes, même généreux, sont détectables par analyse temporelle. Les utilisateurs réels ne visitent pas les pages toutes les 2,0 secondes. Ils lisent, font défiler, cliquent, font des pauses et naviguent de manière non linéaire.

Utilisez une distribution gaussienne (normale) pour les délais. Cela produit une variation semblable à celle des humains, où la plupart des délais se regroupent autour d’une moyenne, mais peuvent parfois être plus longs :

import numpy as np
import time
import random

def human_delay(mean=4.0, std=1.5, min_delay=1.0):
    """Générer un délai similaire à celui d'un humain à l'aide d'une distribution normale."""
    delay = np.random.normal(mean, std)
    # S'assurer de ne pas descendre en dessous du minimum
    delay = max(delay, min_delay)
    time.sleep(delay)

# Entre les requêtes de page
human_delay(mean=4.0, std=1.5)

# Entre les actions sur la même page (plus rapide)
human_delay(mean=1.2, std=0.4)

Au-delà du timing, simulez un comportement de session réaliste avec Playwright : faites défiler la page progressivement avant d’extraire les données, déplacez la souris vers les éléments avant de cliquer et variez le point d’entrée de votre crawl plutôt que de toujours naviguer directement vers l’URL cible.

# Simulez le comportement de défilement humain avant d'extraire le contenu
page.evaluate("window.scrollTo(0, document.body.scrollHeight * 0.3)")
time.sleep(random.uniform(0.8, 2.0))
page.evaluate("window.scrollTo(0, document.body.scrollHeight * 0.7)")
time.sleep(random.uniform(0.5, 1.5))

8. Traitez automatiquement les CAPTCHA

Les CAPTCHA constituent un obstacle, mais pas une impasse. Cependant, leur résolution manuelle n’est pas évolutive. Pour le scraping web en production, vous avez besoin d’une gestion automatisée des CAPTCHA. Passer en revue les meilleurs solveurs de CAPTCHA pour le scraping web vous aidera à choisir l’outil adapté à votre cas d’utilisation.

Les principales approches :

• Services de résolution tiers (2captcha, Anti-Captcha) : envoyez l’image CAPTCHA ou la clé du site à des solveurs humains ou à des modèles d’IA, recevez le jeton, insérez-le dans le formulaire.
• Gestion des scores reCAPTCHA v3: reCAPTCHA v3 fonctionne en silence et attribue un score de risque. Plus votre score est élevé, moins vous êtes susceptible de voir apparaître un défi. Une bonne hygiène de session (en-têtes réalistes, timing, historique de navigation) permet donc de maintenir des scores élevés.
• Solutions gérées: Web Unlocker de Bright Data comprend un solveur CAPTCHA intégré qui gère reCAPTCHA, hCaptcha et Cloudflare Turnstile de manière transparente, sans aucune intégration requise.

import requests

# Avec Bright Data Web Unlocker, la résolution de CAPTCHA est effectuée automatiquement
# avant que la réponse ne soit renvoyée. Aucune intégration de solveur n'est nécessaire.
response = requests.get(
    "https://target-site.com/product-page",
    proxies={
        "https": "https://username:[email protected]:33335"
    },
    verify=False  # Web Unlocker utilise son propre certificat SSL
)

print(response.status_code)  # Renvoie 200 avec le contenu entièrement rendu

9. Évitez les pièges Honeypot

Les liens honeypot sont invisibles pour les utilisateurs réels, mais visibles dans le code HTML brut. Les suivre est un signal instantané de bot.

Détectez-les avant de suivre les liens en vérifiant la visibilité CSS :

from bs4 import BeautifulSoup

def is_visible(tag):
    """Renvoie False si l'élément est masqué via CSS."""
    style = tag.get("style", "")
    if "display:none" in style.replace(" ", "") or 
       "visibility:hidden" in style.replace(" ", ""):
        return False
    # Vérifiez également les noms de classes honeypot courants
    classes = tag.get("class", [])
    honeypot_classes = {"hidden", "invisible", "honeypot", "trap"}
    if honeypot_classes.intersection(set(classes)):
        return False
    return True

soup = BeautifulSoup(html_content, "html.parser")
safe_links = [
    a["href"] for a in soup.find_all("a", href=True)
    if is_visible(a)
]

Cela ne permet pas de détecter tous les honeypots, car certains sont masqués par des classes CSS externes plutôt que par des styles en ligne. La méthode page.is_visible() de Playwright est plus fiable, car elle évalue le style CSS calculé plutôt que les seuls attributs en ligne.

10. Gérer la limitation du débit avec un backoff exponentiel

Pour les réponses HTTP 429 (Too Many Requests), réessayer immédiatement est contre-productif, car cela accélère le blocage. Implémentez un backoff exponentiel pour reculer en douceur et reprendre le scraping sans déclencher une interdiction plus sévère :

import time
import random
import requests

def fetch_with_backoff(url, headers, proxies, max_retries=5):
    """Réessayer avec un backoff exponentiel sur les réponses de limitation de débit."""
    for attempt in range(max_retries):
        response = requests.get(url, headers=headers, proxies=proxies, timeout=15)

        if response.status_code == 200:
            return response
        elif response.status_code == 429:
            # Respecter l'en-tête Retry-After s'il est présent
            retry_after = int(response.headers.get("Retry-After", 2 ** attempt))
            print(f"Taux limité. En attente de {retry_after}s (tentative {attempt + 1})")
            time.sleep(retry_after)
        elif response.status_code in (403, 503):
            # Probablement bloqué, changer d'adresse IP et reculer
            print(f"Bloqué (HTTP {response.status_code}). Recul...")
            time.sleep(2 ** tentative + random.uniform(0, 1))
        else:
            response.raise_for_status()

    raise Exception(f"Nombre maximal de tentatives dépassé pour {url}")

11. Adapter le contexte géographique

De nombreux sites proposent des contenus différents ou appliquent une détection plus stricte des robots en fonction de l’origine géographique des requêtes. Un Scraper de prix de produits ciblant un site de commerce électronique américain doit acheminer les requêtes via des IPs résidentielles américaines, et non allemandes ou singapouriennes. Une géographie incompatible crée une incohérence entre l’origine de la requête et les en-têtes Accept-Language ou locale, que les systèmes d’analyse comportementale peuvent signaler.

Le réseau de Proxies de Bright Data prend en charge le ciblage par pays, état, ville et opérateur, ce qui permet à vos requêtes de provenir du contexte géographique précis attendu par le site cible. Vous pouvez explorer tous les emplacements IP Proxy disponibles avant d’élaborer votre stratégie de ciblage géographique.

12. Exploitez les API sous-jacentes

Avant de créer un Scraper complexe, vérifiez si le site cible expose une API interne utilisée par son frontend. Ouvrez les outils de développement de votre navigateur, allez dans l’onglet Réseau et observez les requêtes XHR/Fetch pendant que vous naviguez sur le site. De nombreux sites, y compris les grandes plateformes de commerce électronique, chargent leurs données à partir de points de terminaison JSON qui sont beaucoup plus faciles à appeler directement que l’analyse HTML.

Ces API internes ont souvent des réponses JSON structurées (aucune analyse HTML requise), un contrôle anti-bot moins strict que la page principale rendue et des paramètres de pagination faciles à automatiser.

Le compromis : les API internes ne sont pas documentées, peuvent changer sans préavis et peuvent nécessiter des jetons d’authentification qui doivent être obtenus via le site principal. Mais lorsqu’elles sont disponibles et stables, elles constituent le moyen de scraping le plus efficace qui soit.

La méthode la plus rapide : utiliser une API de Scraping web

Les 12 techniques ci-dessus nécessitent toutes une mise en œuvre individuelle, une maintenance et une adaptation continue à mesure que les systèmes anti-bot évoluent. À grande échelle, la gestion de cette pile devient un travail à part entière.

L’alternative : consolider l’ensemble de la pile en un seul appel API.

Bright Data Web Unlocker

Web Unlocker est une passerelle Proxy alimentée par l’IA qui gère automatiquement la rotation des IP, la correspondance des empreintes TLS, la Résolution de CAPTCHA et le rendu du navigateur en fonction des exigences du site cible. Vous effectuez une requête HTTP standard. Web Unlocker décide du type de Proxy à utiliser, de l’empreinte à présenter, de la nécessité de réaliser la Résolution de CAPTCHA et du rendu JavaScript, puis renvoie un contenu propre, quelle que soit la complexité de l’anti-bot du site.

import requests

response = requests.get(
    "https://any-protected-site.com/data",
    proxies={"https": "https://user:[email protected]:33335"},
    verify=False,)


# Renvoie un contenu entièrement rendu et débloqué.
print(response.text)

Web Unlocker est testé et mis à jour en permanence par rapport à Cloudflare, Akamai, DataDome et PerimeterX. Un seul appel API remplace 10 techniques manuelles.

Navigateur de scraping Bright Data

Pour les sites qui nécessitent une interaction complète avec le navigateur, y compris les flux en plusieurs étapes, les séquences de connexion et les SPA riches en JavaScript, le Navigateur de scraping fournit une instance Chromium pré-renforcée accessible via CDP. Il s’intègre directement à Playwright et Puppeteer et passe les contrôles d’empreintes digitales de Cloudflare Turnstile et Akamai Bot Manager sans aucune configuration de plugin.

from playwright.sync_api import sync_playwright

SBR_WS_CDP = "wss://brd-customer-XXXX:[email protected]:9222"

avec sync_playwright() comme pw :
    browser = pw.chromium.connect_over_cdp(SBR_WS_CDP)
    page = browser.new_page()
    page.goto("https://cloudflare-protected-site.com")
    print(page.inner_text("body"))
    browser.close()

API Bright Data Scraper

Pour les équipes qui ont besoin de données structurées provenant de plateformes spécifiques sans avoir à écrire ou à maintenir une Infrastructure de scraping, les API Scraper de Bright Data offrent une bibliothèque de plus de 120 Scrapers prêts à l’emploi pour les domaines les plus populaires : Amazon, LinkedIn, Instagram, Zillow, Indeed, TikTok, Walmart, Booking.com, Glassdoor, et bien d’autres encore.

Chaque Scraper accepte une URL ou un mot-clé en entrée, gère tous les débloquages et rendus en interne, et renvoie des données structurées propres au format JSON ou CSV. Aucune gestion de Proxy, aucune maintenance de parseur et aucun réglage d’empreinte digitale ne sont nécessaires. Vous ne payez que pour les enregistrements livrés avec succès.

# Exemple : déclencher un scraping de produit Amazon via les API Scraper
curl -H "Authorization: Bearer API_TOKEN" 
     -H "Content-Type: application/json" 
     -d '[{"url":"https://www.amazon.com/dp/B0CRMZHDG8","asin":"B0CRMZHDG8","zipcode":"94107"}]' 
     « https://api.brightdata.com/Jeux de données/v3/trigger?dataset_id=gd_l7q7dkf244hwjntr0&format=json »

Des scrapers dédiés sont disponibles pour les plateformes de commerce électronique, LinkedIn et les réseaux sociaux, avec des résultats livrables via webhook, API polling ou téléchargement direct. Pour les domaines qui ne sont pas encore couverts, Scraper Studio vous permet de créer un scraper personnalisé à l’aide de l’IA, sans aucun travail d’infrastructure requis.

Proxys résidentiels Bright Data

Pour les scénarios dans lesquels vous gérez votre propre infrastructure de scraping mais avez besoin d’un pool d’adresses IP fiable et à grande échelle : le réseau de proxys résidentiels de Bright Data couvre plus de 150 millions d’adresses IP dans plus de 195 pays, avec un ciblage géographique granulaire jusqu’au niveau de la ville et de l’opérateur. Il comprend plus de 7 millions d’adresses IP mobiles pour le trafic des opérateurs mobiles et des Proxys ISP pour les IPs résidentielles statiques avec des scores de confiance élevés.

Systèmes anti-bots : ce à quoi vous êtes confronté

Cloudflare

Cloudflare Bot Management est le système anti-bot le plus largement déployé, protégeant des millions de sites, y compris la plupart des grands sites de commerce électronique et de médias. Il fonctionne par couches : défis JavaScript (y compris Turnstile), notation de la réputation IP, empreintes digitales TLS/JA4 et analyse comportementale. Le cookie cf_clearance de Cloudflare, une fois obtenu en passant un défi dans un navigateur réel, peut être réutilisé dans son TTL. La détection repose en grande partie sur l’exposition navigator.webdriver, les ensembles d’en-têtes incohérents et les hachages JA4 non liés au navigateur. Pour un aperçu technique complet des méthodes qui fonctionnent, consultez notre guide sur la manière de contourner Cloudflare.

Akamai Bot Manager

Akamai collecte les données des capteurs côté client (canvas, polices, fuseau horaire, WebGL) via un JavaScript injecté et les valide côté serveur par rapport au jeton de cookie abck. Il recoupe simultanément les empreintes digitales TLS/JA3 et les jetons de session, de sorte qu’il ne suffit pas de corriger une seule couche. Akamai est couramment utilisé sur les sites d’entreprises de vente au détail, de compagnies aériennes et de services financiers. Des suites de chiffrement incompatibles peuvent à elles seules déclencher un blocage temporaire ou une erreur 403.

DataDome

DataDome protège à la fois contre le scraping des navigateurs et le scraping des API grâce à un scoring en temps réel basé sur le ML. Il valide conjointement l’ASN IP, la cadence des requêtes, l’entropie des en-têtes et les signaux JavaScript côté client. Les validations échouées renvoient une page distinctive « Accès refusé. Propulsé par DataDome. ». L’automatisation complète du navigateur avec des IPs résidentielles mobiles et des sessions persistantes est nettement plus performante contre DataDome que les clients HTTP bruts.

PerimeterX / HUMAN

PerimeterX (aujourd’hui HUMAN Security) est spécialisé dans l’analyse comportementale, le suivi des mouvements de la souris, des frappes au clavier, de la profondeur de défilement, des événements de mise au point/flou et du timing tout au long d’une session complète afin de créer une empreinte comportementale. Il compare les sessions à des références humaines et attribue des scores aux bots. Il utilise notamment une stratégie d’application différée, qui permet aux bots suspects de naviguer librement tout en accumulant des preuves comportementales avant de les bloquer. Cela signifie que vos premières requêtes peuvent aboutir avant qu’un blocage ne se déclenche.

Comparaison : mécanismes de blocage et contre-mesures

Résumé

Il n’existe pas de technique unique permettant de contourner tous les systèmes anti-bot. Les systèmes de détection modernes reposent sur plusieurs niveaux : réputation IP, empreinte TLS, empreinte du navigateur et analyse comportementale. Pour les contourner, il faut donc agir simultanément sur tous ces niveaux.

Pour le développement et le scraping à faible volume : commencez par des Proxys résidentiels, des en-têtes réalistes, curl_cffi pour la gestion des empreintes TLS et Playwright avec playwright-stealth pour les sites riches en JavaScript.

Pour le scraping à l’échelle de la production : la complexité liée à la maintenance manuelle de toutes ces couches, y compris la rotation des empreintes, la mise à jour des plugins furtifs, la gestion des pools de proxies et la résolution de CAPTCHA, est considérable. Les solutions de Bright Data regroupent la rotation IP, la gestion des empreintes TLS, la résolution de CAPTCHA et le rendu du navigateur en un seul appel API. Vous pouvez ainsi vous concentrer sur les données, et non sur l’infrastructure.

FAQ

Un site web peut-il détecter que vous effectuez du scraping ?

Oui. Les sites web détectent les Scrapers à l’aide de la réputation IP, de l’analyse des en-têtes HTTP, des empreintes digitales TLS, des empreintes digitales du navigateur, des défis CAPTCHA et de l’analyse comportementale. La plupart des détections se produisent en quelques millisecondes avant que le contenu de la page ne soit servi.

Pourquoi les scrapers web sont-ils bloqués ?

Les scrapers sont bloqués lorsqu’ils effectuent trop de requêtes à partir d’une seule adresse IP, envoient des en-têtes HTTP non humains, échouent aux vérifications d’empreintes TLS ou de navigateur, ou déclenchent des défis CAPTCHA. Les Proxys résidentiels et les navigateurs furtifs réduisent tous ces risques.

Quelle est la meilleure façon de scraper sans être bloqué ?

L’approche la plus fiable combine des Proxys résidentiels rotatifs, des en-têtes de requête réalistes, des délais aléatoires et un navigateur sans interface avec des plugins furtifs. Pour le scraping à l’échelle de la production, une solution gérée telle que Web Unlocker de Bright Data gère tout cela automatiquement, en consolidant la rotation des adresses IP, la gestion des empreintes TLS, la Résolution de CAPTCHA et le rendu du navigateur en un seul appel API.

Le scraping web est-il légal ?

Le scraping web de données accessibles au public est généralement légal dans la plupart des juridictions, en particulier pour les données non personnelles et non protégées par des droits d’auteur. Vérifiez toujours le fichier robots.txt et les conditions d’utilisation du site cible. Le scraping de données personnelles peut être soumis à des restrictions en vertu du RGPD, du CCPA et de lois similaires. Aux États-Unis, l’arrêt hiQ v. LinkedIn a confirmé que le scraping web de données publiques ne violait pas la loi sur la fraude et les abus informatiques (Computer Fraud and Abuse Act).

Qu’est-ce que l’empreinte TLS ?

Le fingerprinting TLS identifie le type de client (navigateur, bot ou script) en analysant la combinaison unique de suites de chiffrement, de versions TLS et d’extensions utilisées lors de la négociation HTTPS. Les systèmes anti-bot utilisent les hachages JA3 et JA4 pour bloquer les outils de scraping connus, tels que la bibliothèque de requêtes Python. Implication clé : même des en-têtes HTTP parfaitement réalistes ne vous aideront pas si votre pile TLS ressemble à OpenSSL plutôt qu’à Chrome.

Pourquoi les Proxys résidentiels fonctionnent-ils mieux que les Proxys de centre de données ?

Les proxys résidentiels acheminent le trafic via de véritables adresses IP attribuées par les FAI. Les systèmes anti-bot vérifient le numéro ASN (Autonomous System Number) de chaque IP entrante. Les adresses IP des centres de données appartiennent à des ASN bien connus (AWS, GCP, etc.) qui sont bloqués par défaut sur les sites hautement sécurisés. Les IPs résidentielles appartiennent à des FAI tels que Comcast ou BT, ce qui les rend impossibles à distinguer du trafic réel des utilisateurs au niveau de la couche réseau. Pour une analyse complète des différences de performances, consultez notre comparaison entre les proxys de centre de données et les proxys résidentiels.