Proxys pour le web scraping : guide des types, de la confidentialité et de la détection

Le web scraping se heurte presque toujours au même mur : le site voit qu'un nombre suspect de requêtes arrive depuis une même adresse IP, et il se met à bloquer, à afficher des captchas ou à renvoyer des pages « vides ». Les proxys résolvent ce problème — ils remplacent votre IP réelle par une adresse tierce et répartissent la charge. Mais tous les proxys ne se valent pas : il en existe des dizaines de types, et ce choix détermine si votre scraper passera inaperçu ou grillera dès la première centaine de requêtes.

Voici un tour d'horizon de tous les principaux types de proxys, de leurs propriétés, des niveaux de confidentialité et de la tarification, avec des exemples de code dans plusieurs langages.

Qu'est-ce qu'un proxy et à quoi sert-il en web scraping

Un serveur proxy est un intermédiaire entre votre scraper et le site cible. La requête ne part pas en direct, elle passe par le proxy : le site voit l'IP du proxy, pas la vôtre. En web scraping, cela apporte trois choses :

1. Masquer l'IP réelle — il devient plus difficile de vous identifier et de vous bannir personnellement.
2. Répartir la charge — un pool de centaines d'IP permet d'envoyer beaucoup de requêtes sans dépasser les limites propres à chaque adresse.
3. Contourner les restrictions géographiques — vous collectez les données comme si vous étiez dans le pays voulu (prix, résultats de recherche et contenu dépendent souvent de la région).

Classification par protocole : HTTP, HTTPS, SOCKS

C'est la première chose à comprendre — à quel niveau travaille le proxy.

Proxy HTTP

Il ne gère que le trafic HTTP. Il « comprend » la structure de la requête HTTP, peut lire et modifier les en-têtes, mettre les réponses en cache. Pour scraper des sites ordinaires, c'est souvent suffisant.

Proxy HTTPS (HTTP CONNECT)

La même chose, mais il sait tunneliser le trafic TLS chiffré via la méthode CONNECT. Le proxy ne voit pas le contenu (il est chiffré), il se contente de relayer les octets. Aujourd'hui, presque tout le web est en HTTPS, la prise en charge de CONNECT est donc indispensable.

SOCKS4 et SOCKS5

SOCKS travaille à un niveau plus bas — c'est un tunnel universel pour n'importe quel trafic TCP (et même UDP pour SOCKS5). Le proxy n'inspecte pas le contenu : peu lui importe qu'il s'agisse de HTTP, de FTP, de WebSocket ou d'autre chose.

Différence entre un proxy SOCKS et un proxy HTTP :

Différence SOCKS4 vs SOCKS5 :

• SOCKS4 — ancien : pas d'authentification par mot de passe, pas d'IPv6 ni d'UDP, et pas de résolution DNS côté proxy (le domaine est converti en IP de votre côté — c'est une fuite : vos requêtes DNS permettent de voir ce que vous scrapez).
• SOCKS5 — prend en charge l'authentification, IPv6, UDP et la résolution DNS distante (socks5h dans le schéma d'URL). Préférable pour le scraping, car le DNS ne fuit pas.

Règle pratique : si vous hésitez entre les deux, prenez SOCKS5 (et utilisez dans le code le schéma socks5h://, afin que le DNS soit résolu via le proxy).

Classification par origine de l'IP

Bien plus important que le protocole : d'où vient l'adresse IP. C'est cela qui détermine à quel point vous paraissez « humain » aux yeux des systèmes anti-bots.

Proxys datacenter (Datacenter)

Les IP appartiennent à des hébergeurs et à des datacenters (AWS, OVH, Hetzner, etc.).

• ➕ Bon marché, très rapides, disponibles par milliers.
• ➖ Faciles à détecter : les systèmes anti-bots maintiennent des bases de sous-réseaux de datacenters. Beaucoup de sites bloquent ces IP de façon préventive.
• Adaptés au scraping de sites « conciliants », sans protection sérieuse.

Proxys résidentiels (Residential)

Les IP de vrais particuliers, attribuées par des fournisseurs d'accès à Internet (FAI). Le trafic transite par les appareils de personnes réelles (souvent via des réseaux P2P ou des SDK intégrés à des applications).

• ➕ Ils ressemblent à des utilisateurs ordinaires et sont difficiles à distinguer d'un trafic réel.
• ➖ Plus chers, plus lents, parfois instables.
• Adaptés aux sites dotés d'une protection sérieuse (marketplaces, réseaux sociaux, moteurs de recherche).

Proxys mobiles (Mobile)

Les IP des opérateurs mobiles (3G/4G/5G). Particularité : les opérateurs utilisent le CGNAT — des centaines d'abonnés réels se partagent une même IP.

• ➕ Le niveau de confiance le plus élevé : bannir une telle IP = bannir une foule de personnes réelles, les sites sont donc prudents.
• ➖ Les plus chers ; vitesse et stabilité moindres.
• À réserver aux cas où tout le reste se fait bannir instantanément.

Proxys ISP (Static Residential)

Un hybride : les IP appartiennent formellement à un fournisseur d'accès (comme les résidentielles), mais sont physiquement hébergées en datacenter (comme les proxys datacenter).

• ➕ La vitesse d'un datacenter + la réputation d'un FAI. Statiques (elles ne changent pas), ce qui est pratique pour les sessions longues.
• ➖ Plus chers que les proxys datacenter.

Comparaison rapide selon la « discrétion » et le prix :

Datacenter   →  ISP   →  Résidentiels  →  Mobiles
moins cher/                         plus cher/
plus visible                        plus discret

IPv4 vs IPv6

L'espace d'adressage IPv4 est épuisé — les adresses sont rares et chères. IPv6 est pratiquement illimité, c'est pourquoi les proxys IPv6 sont nettement moins chers.

Mais il y a un piège : un proxy IPv6 ne fonctionne que si le site cible prend en charge IPv6. Beaucoup de grands sites sont encore en IPv4 uniquement — un proxy IPv6 ne pourra alors tout simplement pas s'y connecter.

Conclusion : IPv6 est intéressant côté prix pour scraper des sites qui gèrent IPv6 à coup sûr (Google, de nombreux services internationaux). Pour le reste et pour une compatibilité maximale — IPv4.

Niveaux de confidentialité (anonymat) des proxys

Un proxy peut vous « trahir » de différentes manières — en ajoutant des en-têtes HTTP techniques à la requête. Selon ce qui est transmis, on distingue trois niveaux.

1. Transparent

Il transmet votre IP réelle dans les en-têtes et annonce ouvertement qu'il s'agit d'un proxy.

Via: 1.1 proxy
X-Forwarded-For: VOTRE_IP_REELLE

Pour le scraping, il est inutile — le site voit à la fois le proxy et vous. Ces proxys équipent souvent des réseaux d'entreprise ou publics à des fins de cache.

2. Anonymous (anonyme)

Il masque votre IP réelle, mais ne cache pas le fait même qu'un proxy est utilisé.

Via: 1.1 proxy
X-Forwarded-For: IP_DU_PROXY   (ou absent, mais Via trahit le proxy)

L'IP réelle est protégée, mais le système anti-bot voit l'étiquette « ceci est un proxy » et peut se montrer méfiant.

3. Elite / High Anonymous (élite)

Il ne transmet ni votre IP, ni aucun signe de proxy. La requête semble émise en direct, sans intermédiaire.

(aucun Via, X-Forwarded-For, X-Real-IP, Proxy-Connection)

Pourquoi certains proxys transmettent-ils ces données et d'autres non ? Tout tient à la configuration du serveur proxy lui-même. Les transparents ajoutent délibérément X-Forwarded-For pour que le serveur cible connaisse le client d'origine (c'est voulu pour les proxys de cache ou d'entreprise). Les élites sont configurés pour purger tous ces en-têtes. En-têtes qui trahissent un proxy : Via, X-Forwarded-For, X-Real-IP, Forwarded, Proxy-Connection, X-Proxy-ID.

Pour le scraping, il faut uniquement des proxys Elite. Anonymous — à vos risques et périls, Transparent — jamais.

Rotation : proxys statiques et rotatifs

• Statiques (sticky) — la même IP reste en place longtemps. Indispensables quand il faut une session (connexion, panier), pour que le site ne vous « perde » pas au changement d'IP.
• Rotatifs (rotating) — l'IP change automatiquement : à chaque requête ou toutes les N minutes. Parfaits pour la collecte massive où la session n'a pas d'importance. Le fournisseur expose souvent un seul endpoint « passerelle » et assure la rotation de son côté à partir d'un pool de milliers d'adresses.

TOR comme proxy gratuit

TOR (The Onion Router) est un réseau anonyme dans lequel le trafic traverse une chaîne de trois nœuds : d'entrée (guard/entry), intermédiaire (middle) et de sortie (exit). Chaque couche de chiffrement est retirée sur son nœud — d'où le routage « en oignon ». En local, TOR lance un proxy SOCKS5 (port 9050 par défaut) auquel on peut connecter son scraper.

Oui, TOR permet aussi de choisir la géolocalisation et les nœuds. Le fichier de configuration torrc permet de contrôler par quels pays sortir sur Internet :

# Ne sortir que par des nœuds situés dans ces pays
ExitNodes {us},{de},{nl}
StrictNodes 1

# On peut imposer les nœuds d'entrée/de sortie par pays
EntryNodes {de}
ExcludeNodes {ru},{cn}
ExcludeExitNodes {ru}

Les codes pays s'écrivent entre accolades, au format ISO ({us}, {de}, {fr}). StrictNodes 1 interdit de sortir de la liste définie. Pour changer de chaîne (obtenir une nouvelle IP de sortie), envoyez le signal NEWNYM sur le port de contrôle.

Inconvénients de TOR pour le scraping :

• Lent — trois sauts, plus la saturation du réseau.
• Nœuds de sortie sur listes noires — la liste des nœuds de sortie est publique, beaucoup de sites bloquent tout TOR de façon préventive.
• Petit pool d'IP — les nœuds de sortie se comptent en milliers, pas en millions comme chez les fournisseurs résidentiels. La rotation est limitée.
• Convient pour des tâches ponctuelles et l'expérimentation, mais pas pour du scraping industriel.

Listes de proxys gratuits

Internet regorge de sites publiant des listes de proxys gratuits (free proxy lists) — des milliers d'IP:port à télécharger immédiatement. C'est tentant, mais leur qualité est systématiquement mauvaise :

• La plupart sont morts avant même que vous les téléchargiez — 5 à 20 % survivent, dans le meilleur des cas.
• Lents et instables — ils répondent une fois sur deux.
• Souvent transparents — ils divulguent votre IP.
• Déjà sur listes noires — des milliers de personnes les ont utilisés avant vous, les sites sérieux les ont bannis depuis longtemps.
• Risque de sécurité — impossible de savoir qui opère le proxy ; il peut intercepter ou altérer le trafic (particulièrement dangereux en HTTP non chiffré et lors de l'envoi d'identifiants).

Conclusion : les proxys gratuits conviennent pour apprendre et pour des expériences ponctuelles, mais tout scraping sérieux ou commercial exige des proxys payants. C'est précisément pourquoi tout proxy public doit impérativement être vérifié avant usage (voir ci-dessous).

Vérification des proxys

Un proxy ne s'utilise pas tel quel — surtout s'il vient d'une liste publique. Il faut le vérifier, car les proxys « meurent » en permanence, ralentissent et changent de comportement. Ce que l'on contrôle :

1. Est-il vivant — répond-il seulement, et avec quel code de retour.
2. Vitesse / latence — temps de réponse (ping, temps jusqu'au premier octet). Les proxys lents sont écartés.
3. Niveau d'anonymat — divulgue-t-il votre IP réelle. On envoie une requête à un service d'écho (par exemple un endpoint qui renvoie votre IP et vos en-têtes) et on vérifie si X-Forwarded-For ou Via apparaissent.
4. Géolocalisation réelle — une IP annoncée comme « allemande » peut en réalité se trouver dans un autre pays. On vérifie via une base GeoIP.
5. Type/réputation — figure-t-il sur des listes noires, est-il marqué comme datacenter/proxy (via des services de fraud score).
6. Prise en charge HTTPS — le CONNECT passe-t-il, le TLS reste-t-il intact.

Le vérificateur le plus simple en Python — on tente d'atteindre un service d'écho via le proxy et on regarde ce qui revient :

import requests

def check_proxy(proxy: str, timeout: int = 8):
    proxies = {"http": proxy, "https": proxy}
    try:
        r = requests.get("https://httpbin.org/get",
                         proxies=proxies, timeout=timeout)
        data = r.json()
        origin_ip = data.get("origin")
        headers = data.get("headers", {})
        leaked = any(h in headers for h in
                     ("X-Forwarded-For", "Via", "X-Real-Ip"))
        return {
            "ok": True,
            "ip": origin_ip,
            "anonymous": not leaked,   # True = l'IP réelle n'a pas fui
            "latency": r.elapsed.total_seconds(),
        }
    except Exception as e:
        return {"ok": False, "error": str(e)}

print(check_proxy("http://user:pass@1.2.3.4:8080"))

Comment les proxys influencent la détection lors du scraping

Le proxy en soi n'est pas une « cape d'invisibilité ». Les systèmes anti-bots (Cloudflare, DataDome, PerimeterX/HUMAN, Akamai) examinent une multitude de signaux, et l'IP n'est que l'un d'entre eux.

Ce qui trahit un scraper sur le plan de l'IP :

• Le type d'IP. Les sous-réseaux de datacenters sont connus et marqués « non humain ». Les IP résidentielles et mobiles inspirent davantage confiance. C'est le principal facteur sur lequel joue le choix du proxy.
• La réputation de l'IP (fraud score). L'historique de l'adresse : spam, botnets, bannissements passés. Une IP « sale » se fait repérer même si elle est résidentielle.
• La fréquence des requêtes depuis une même IP (rate limiting). Trop de requêtes par seconde = bannissement. Un pool de proxys avec rotation étale la charge et réduit la fréquence par adresse.
• La répartition géographique. Si « un même utilisateur » saute en une minute des États-Unis au Brésil et retour — c'est clairement un bot. Au sein d'une même session, mieux vaut donc garder une IP stable.
• L'ASN. Le numéro de système autonome révèle à qui appartient l'IP (hébergeur ou vrai fournisseur d'accès).

Ce que les proxys NE couvrent PAS (et pourquoi un proxy seul ne suffit pas) :

• L'empreinte TLS/JA3 — la signature de votre poignée de main TLS. Avec requests/curl, elle ne ressemble pas à celle d'un navigateur, et elle reste visible à travers n'importe quel proxy.
• Les en-têtes HTTP et leur ordre — un User-Agent bancal ou non standard, l'absence des en-têtes habituels d'un navigateur.
• Le browser fingerprint — Canvas, WebGL, polices, environnement JS (pertinent pour les navigateurs headless).
• Le comportement — des schémas de clics et de navigation trop rapides, trop réguliers, « non humains ».

Conclusion : un proxy de qualité (résidentiel/mobile, elite, avec une bonne réputation) réduit fortement la détection par IP, mais il doit être combiné avec des en-têtes corrects, un fingerprint réaliste et un rythme de requêtes raisonnable. Le proxy est une condition nécessaire, mais pas suffisante.

Tarification : que payez-vous

Les fournisseurs facturent de différentes manières, et le modèle détermine ce qui est le plus avantageux pour votre tâche.

• Au trafic (per GB). Vous payez les gigaoctets transférés, tandis que le pool d'IP est immense et « gratuit ». Typique des résidentiels/mobiles. Dangereux pour le scraping de pages « lourdes » avec images/vidéos — la facture grimpe vite. Pour économiser : ne télécharger que le HTML, bloquer le chargement des médias.
• Au nombre d'IP (per IP). Vous payez des adresses précises (par exemple 100 proxys statiques datacenter/ISP), avec trafic illimité. Avantageux pour de gros volumes de données et des IP stables.
• Aux ports/threads (per port / per thread). Vous payez le nombre de connexions simultanées, pas le volume. Fréquent chez les proxys mobiles.
• À la requête (per request) ou par abonnement. Typique des scraping API prêtes à l'emploi, où le fournisseur gère lui-même les proxys et livre le HTML final.

Comment choisir : beaucoup de petites requêtes sur des pages légères → per-GB ou per-request ; transfert de gros volumes → per-IP avec trafic illimité.

Exemples de code : connexion à un proxy dans différents langages

Le format de la chaîne proxy est presque partout identique : schéma://utilisateur:motdepasse@hôte:port, par exemple http://user:pass@1.2.3.4:8080.

Python — requests (synchrone)

import requests

proxies = {
    "http":  "http://user:pass@1.2.3.4:8080",
    "https": "http://user:pass@1.2.3.4:8080",
}

r = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)
print(r.json())

# SOCKS5 avec DNS distant (paquet requis : pip install requests[socks])
socks = {"http": "socks5h://user:pass@1.2.3.4:1080",
         "https": "socks5h://user:pass@1.2.3.4:1080"}
print(requests.get("https://httpbin.org/ip", proxies=socks).json())

Python — httpx (asynchrone, avec rotation)

import asyncio, httpx, random

POOL = [
    "http://user:pass@1.2.3.4:8080",
    "http://user:pass@5.6.7.8:8080",
]

async def fetch(url):
    proxy = random.choice(POOL)          # IP aléatoire du pool à chaque requête
    async with httpx.AsyncClient(proxy=proxy, timeout=10) as client:
        resp = await client.get(url)
        return resp.status_code, resp.text[:80]

async def main():
    tasks = [fetch("https://httpbin.org/ip") for _ in range(5)]
    for code, body in await asyncio.gather(*tasks):
        print(code, body)

asyncio.run(main())

Python — TOR (SOCKS5 + changement de chaîne)

import requests
from stem import Signal
from stem.control import Controller

proxies = {"http":  "socks5h://127.0.0.1:9050",
           "https": "socks5h://127.0.0.1:9050"}

print(requests.get("https://httpbin.org/ip", proxies=proxies).json())

# Demander une nouvelle IP de sortie (une nouvelle chaîne)
with Controller.from_port(port=9051) as c:
    c.authenticate(password="votre_mot_de_passe")
    c.signal(Signal.NEWNYM)

Node.js — axios + HttpsProxyAgent

const axios = require("axios");
const { HttpsProxyAgent } = require("https-proxy-agent");

const agent = new HttpsProxyAgent("http://user:pass@1.2.3.4:8080");

axios.get("https://httpbin.org/ip", { httpsAgent: agent, httpAgent: agent })
  .then(res => console.log(res.data))
  .catch(err => console.error(err.message));

Node.js — SOCKS5

const axios = require("axios");
const { SocksProxyAgent } = require("socks-proxy-agent");

// socks5h:// — le DNS est résolu côté proxy
const agent = new SocksProxyAgent("socks5h://user:pass@1.2.3.4:1080");

axios.get("https://httpbin.org/ip", { httpAgent: agent, httpsAgent: agent })
  .then(res => console.log(res.data));

Node.js — Puppeteer (navigateur headless via proxy)

const puppeteer = require("puppeteer");

(async () => {
  const browser = await puppeteer.launch({
    args: ["--proxy-server=http://1.2.3.4:8080"],
  });
  const page = await browser.newPage();
  // authentification sur le proxy, si nécessaire
  await page.authenticate({ username: "user", password: "pass" });
  await page.goto("https://httpbin.org/ip");
  console.log(await page.evaluate(() => document.body.innerText));
  await browser.close();
})();

Go — net/http

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
)

func main() {
    proxyURL, _ := url.Parse("http://user:pass@1.2.3.4:8080")
    client := &http.Client{
        Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
    }
    resp, err := client.Get("https://httpbin.org/ip")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

PHP — cURL

<?php
$ch = curl_init("https://httpbin.org/ip");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_PROXY          => "1.2.3.4:8080",
    CURLOPT_PROXYUSERPWD   => "user:pass",
    CURLOPT_PROXYTYPE      => CURLPROXY_HTTP, // ou CURLPROXY_SOCKS5_HOSTNAME
    CURLOPT_TIMEOUT        => 10,
]);
echo curl_exec($ch);
curl_close($ch);

cURL en ligne de commande

# Proxy HTTP
curl -x http://user:pass@1.2.3.4:8080 https://httpbin.org/ip

# SOCKS5 avec DNS distant
curl --proxy socks5h://user:pass@1.2.3.4:1080 https://httpbin.org/ip

Check-list finale : choisir son proxy pour le scraping

Règles essentielles :

1. Exigez l'anonymat elite — aucune fuite via X-Forwarded-For/Via.
2. Tout proxy public/gratuit doit être vérifié avant la mise en production.
3. Pour les sites protégés — résidentiels ou mobiles, pas de datacenter.
4. Les proxys neutralisent la détection par IP, pas par fingerprint — combinez-les avec des en-têtes corrects et un rythme de requêtes raisonnable.
5. Adaptez la tarification à votre tâche : beaucoup de requêtes légères → per-GB/request, gros volumes → per-IP.