← Retour au blog
RUENZHESARPTDEFRJAKOITTRIDVIFAHI

Configuration de proxy dans curl et wget : guide complet avec des exemples pour le scraping

Guide détaillé sur l'utilisation des proxies dans curl et wget : exemples de commandes, configuration de l'authentification, contournement des blocages lors du parsing et automatisation des requêtes.

📅14 février 2026

Lors du scraping de sites, de l'automatisation des requêtes API ou de la surveillance des prix des concurrents sur les marketplaces, vous serez inévitablement confronté à des blocages par IP. Les outils curl et wget sont des outils standard pour travailler avec des requêtes HTTP en ligne de commande, et la configuration correcte des proxies est cruciale pour contourner ces restrictions. Dans cet article, nous examinerons toutes les façons d'utiliser des proxies dans curl et wget : des commandes de base aux scénarios avancés avec rotation IP et gestion des erreurs.

Syntaxe de base du proxy dans curl et wget

Commençons par les commandes les plus simples pour se connecter via un proxy. Les deux outils prennent en charge un paramètre pour spécifier le serveur proxy, mais la syntaxe diffère légèrement.

Utilisation du proxy dans curl

Dans curl, le proxy est spécifié via le paramètre -x ou --proxy. Le format de base de la commande est : 

curl -x http://proxy-server:port http://example.com

Un exemple concret avec un serveur proxy réel : 

curl -x http://45.130.123.45:8080 http://api.ipify.org

Cette commande enverra une requête à api.ipify.org (un service qui renvoie votre adresse IP) via le serveur proxy spécifié. Vous verrez l'IP du proxy, et non votre véritable adresse.

Utilisation du proxy dans wget

Dans wget, le proxy est configuré via le paramètre -e use_proxy=yes et des variables d'environnement, ou directement via des options : 

wget -e use_proxy=yes -e http_proxy=http://45.130.123.45:8080 http://example.com

Ou une version plus courte via des variables d'environnement (nous en parlerons plus en détail dans la section suivante) : 

export http_proxy="http://45.130.123.45:8080"
wget http://example.com

Authentification sur le serveur proxy

La plupart des services de proxy commerciaux nécessitent une authentification par nom d'utilisateur et mot de passe. Cela protège le proxy contre une utilisation non autorisée et permet de suivre le trafic de chaque client. Voyons comment transmettre les informations d'identification dans curl et wget.

Authentification dans curl

Dans curl, le nom d'utilisateur et le mot de passe peuvent être spécifiés directement dans l'URL du serveur proxy ou via un paramètre séparé -U : 

# Méthode 1 : nom d'utilisateur et mot de passe dans l'URL
curl -x http://username:password@proxy-server:port http://example.com

# Méthode 2 : via le paramètre -U
curl -x http://proxy-server:port -U username:password http://example.com

Un exemple concret avec des informations d'identification : 

curl -x http://user123:pass456@45.130.123.45:8080 http://api.ipify.org

Un point important : si le mot de passe contient des caractères spéciaux (@, :, /, ?), ils doivent être encodés au format URL. Par exemple, le caractère @ est remplacé par %40 : 

# Si le mot de passe contient @ : pass@456
curl -x http://user123:pass%40456@45.130.123.45:8080 http://api.ipify.org

Authentification dans wget

Dans wget, l'authentification est configurée via les paramètres --proxy-user et --proxy-password : 

wget --proxy-user=username --proxy-password=password \
     -e use_proxy=yes -e http_proxy=http://45.130.123.45:8080 \
     http://example.com

Ou via des variables d'environnement avec les informations d'identification dans l'URL : 

export http_proxy="http://username:password@45.130.123.45:8080"
wget http://example.com

Travailler avec différents types de proxy : HTTP, HTTPS, SOCKS5

Les serveurs proxy fonctionnent selon différents protocoles, et le choix du type dépend de la tâche. Les proxies HTTP conviennent pour des requêtes simples, les HTTPS assurent le chiffrement, et les SOCKS5 fonctionnent à un niveau plus bas et prennent en charge tout type de trafic. Lors du scraping de marketplaces comme Wildberries ou Ozon, on utilise souvent des proxies résidentiels, qui peuvent fonctionner selon l'un de ces protocoles.

Proxies HTTP et HTTPS

Les proxies HTTP sont le type le plus courant. Ils fonctionnent au niveau du protocole HTTP et conviennent à la plupart des tâches de web scraping : 

# Proxy HTTP dans curl
curl -x http://proxy-server:8080 http://example.com

# Proxy HTTPS dans curl (pour les connexions sécurisées)
curl -x https://proxy-server:8080 https://example.com

Important : même si le site cible utilise HTTPS, le proxy peut être HTTP. Curl établira automatiquement un tunnel via la méthode CONNECT : 

# Proxy HTTP pour un site HTTPS (fonctionne correctement)
curl -x http://proxy-server:8080 https://secure-site.com

Proxies SOCKS5

SOCKS5 est un protocole plus universel qui fonctionne au niveau TCP et prend en charge tout type de trafic (HTTP, HTTPS, FTP, même UDP). Cela rend SOCKS5 idéal pour des tâches d'automatisation complexes : 

# SOCKS5 dans curl
curl -x socks5://proxy-server:1080 http://example.com

# SOCKS5 avec authentification
curl -x socks5://username:password@proxy-server:1080 http://example.com

# SOCKS5h (résolution DNS via le proxy)
curl -x socks5h://proxy-server:1080 http://example.com

La différence entre socks5 et socks5h : dans le premier cas, les requêtes DNS proviennent de votre ordinateur, dans le second — via le serveur proxy. Utilisez socks5h si vous souhaitez cacher complètement votre activité, y compris les requêtes DNS.

Dans wget, le support de SOCKS5 est limité, donc pour de telles tâches, il est préférable d'utiliser curl ou des utilitaires supplémentaires comme proxychains.

Conseil : Pour le scraping des marketplaces (Wildberries, Ozon, Yandex.Market), il est recommandé d'utiliser des proxies résidentiels ou mobiles avec le protocole HTTP/HTTPS — ils sont moins souvent bloqués, car ils ont des IP de véritables utilisateurs.

Configuration du proxy via des variables d'environnement

Si vous travaillez régulièrement via un proxy, il est plus pratique de configurer les variables d'environnement une fois plutôt que de spécifier les paramètres dans chaque commande. Curl et wget lisent automatiquement ces variables.

Configuration pour la session actuelle

Exportez les variables dans le terminal (elles sont valables jusqu'à la fermeture de la session) : 

# Pour le trafic HTTP
export http_proxy="http://username:password@proxy-server:8080"

# Pour le trafic HTTPS
export https_proxy="http://username:password@proxy-server:8080"

# Pour le trafic FTP
export ftp_proxy="http://username:password@proxy-server:8080"

# Pour SOCKS5
export all_proxy="socks5://username:password@proxy-server:1080"

Après cela, curl et wget utiliseront automatiquement le proxy : 

# Le proxy sera appliqué automatiquement
curl http://api.ipify.org
wget http://example.com

Configuration permanente dans .bashrc ou .zshrc

Pour que les proxies soient appliqués à chaque ouverture de terminal, ajoutez les variables dans le fichier de configuration de votre shell : 

# Ouvrez le fichier dans un éditeur
nano ~/.bashrc  # pour bash
# ou
nano ~/.zshrc   # pour zsh

# Ajoutez à la fin du fichier :
export http_proxy="http://username:password@proxy-server:8080"
export https_proxy="http://username:password@proxy-server:8080"

# Enregistrez et appliquez les modifications :
source ~/.bashrc

Exceptions : no_proxy

Parfois, il est nécessaire d'exclure certaines adresses du proxy (par exemple, localhost ou des services internes) : 

export no_proxy="localhost,127.0.0.1,192.168.0.0/16,.local"

Désormais, les requêtes vers ces adresses passeront directement, sans passer par le proxy.

Rotation des proxies dans les scripts bash

Lors du scraping massif (par exemple, la collecte des prix de milliers de fiches produits sur Wildberries), l'utilisation d'un seul proxy entraînera un blocage. La solution consiste à faire tourner les adresses IP. Voyons comment mettre cela en œuvre dans des scripts bash.

Rotation simple à partir d'une liste de proxies

Créez un fichier proxies.txt avec une liste de serveurs proxy (un par ligne) : 

http://user1:pass1@proxy1.example.com:8080
http://user2:pass2@proxy2.example.com:8080
http://user3:pass3@proxy3.example.com:8080

Script pour une rotation séquentielle des proxies : 

#!/bin/bash

# Fichier avec la liste des URL à scraper
urls_file="urls.txt"
# Fichier avec la liste des proxies
proxies_file="proxies.txt"

# Lire les proxies dans un tableau
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current_proxy=0

# Traiter chaque URL
while IFS= read -r url; do
    # Choisir un proxy en rotation
    proxy="${proxies[$current_proxy]}"
    
    echo "Requête à $url via $proxy"
    curl -x "$proxy" -s "$url" -o "output_$(basename $url).html"
    
    # Passer au proxy suivant
    current_proxy=$(( (current_proxy + 1) % proxy_count ))
    
    # Pause entre les requêtes (1-3 secondes)
    sleep $((RANDOM % 3 + 1))
done < "$urls_file"

Ce script utilise séquentiellement les proxies de la liste, revenant au premier après le dernier. Une pause aléatoire entre les requêtes rend l'activité plus naturelle.

Choix aléatoire de proxy

Pour plus d'imprévisibilité, vous pouvez choisir un proxy de manière aléatoire : 

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}

while IFS= read -r url; do
    # Choix aléatoire de proxy
    random_index=$((RANDOM % proxy_count))
    proxy="${proxies[$random_index]}"
    
    echo "Requête à $url via le proxy #$random_index"
    curl -x "$proxy" -s "$url" -o "output_$(date +%s).html"
    
    sleep $((RANDOM % 3 + 1))
done < "urls.txt"

Rotation automatique via l'API du service proxy

De nombreux fournisseurs de proxies (y compris les services fournissant des proxies résidentiels) proposent une rotation automatique via un point d'entrée unique. Vous utilisez une seule adresse proxy, et l'IP change à chaque requête ou selon un minuteur : 

# Proxy avec rotation automatique
# L'IP change à chaque requête
curl -x http://username:password@rotating.proxy.com:8080 http://api.ipify.org
curl -x http://username:password@rotating.proxy.com:8080 http://api.ipify.org

# Les deux requêtes ci-dessus obtiendront des adresses IP différentes

C'est la méthode la plus pratique pour le scraping à grande échelle — pas besoin de gérer manuellement une liste de proxies.

Transmission des en-têtes et User-Agent via le proxy

Les sites modernes analysent non seulement l'adresse IP, mais aussi les en-têtes HTTP de la requête. L'absence de User-Agent ou des en-têtes suspects peuvent entraîner un blocage même lors de l'utilisation de proxies de qualité. Voyons comment configurer correctement les en-têtes dans curl et wget.

User-Agent dans curl

User-Agent est un en-tête qui identifie le navigateur et le système d'exploitation. Curl envoie par défaut son propre User-Agent (curl/7.x.x), ce qui révèle immédiatement l'automatisation. Remplacez-le par un véritable navigateur : 

# Chrome sur Windows
curl -x http://proxy:8080 \
     -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" \
     http://example.com

# Firefox sur macOS
curl -x http://proxy:8080 \
     -A "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0" \
     http://example.com

En-têtes supplémentaires

Pour une requête plus réaliste, ajoutez des en-têtes typiques de navigateur : 

curl -x http://proxy:8080 \
     -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
     -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" \
     -H "Accept-Language: ru-RU,ru;q=0.9,en;q=0.8" \
     -H "Accept-Encoding: gzip, deflate, br" \
     -H "Connection: keep-alive" \
     -H "Upgrade-Insecure-Requests: 1" \
     http://example.com

User-Agent dans wget

Dans wget, le User-Agent est défini via le paramètre --user-agent : 

wget --user-agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
     -e use_proxy=yes -e http_proxy=http://proxy:8080 \
     http://example.com

Randomisation du User-Agent dans les scripts

Pour le scraping à grande échelle, il est utile de varier le User-Agent, afin que les requêtes semblent provenir de différents utilisateurs : 

#!/bin/bash

# Tableau User-Agent
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0 Safari/537.36"
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Safari/605.1.15"
    "Mozilla/5.0 (X11; Linux x86_64) Firefox/121.0"
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) Safari/604.1"
)

while IFS= read -r url; do
    # User-Agent aléatoire
    random_ua=${user_agents[$RANDOM % ${#user_agents[@]}]}
    
    curl -x http://proxy:8080 -A "$random_ua" -s "$url"
    sleep 2
done < "urls.txt"

Diagnostic des problèmes et gestion des erreurs

Lors de l'utilisation de proxies, des erreurs surviennent souvent : délais d'attente, refus de connexion, authentification incorrecte. Voyons comment diagnostiquer et gérer ces situations.

Vérification du bon fonctionnement du proxy

La façon la plus simple de vérifier un proxy est de demander un service qui renvoie votre IP : 

# Vérification du proxy HTTP
curl -x http://proxy:8080 http://api.ipify.org

# Vérification du proxy SOCKS5
curl -x socks5://proxy:1080 http://api.ipify.org

# Avec affichage d'informations détaillées
curl -x http://proxy:8080 -v http://api.ipify.org

Le paramètre -v (verbose) affichera les détails de la connexion, y compris les en-têtes et les erreurs.

Gestion des délais d'attente

Les proxies lents ou les serveurs surchargés peuvent provoquer des délais d'attente. Définissez des limites de temps raisonnables : 

# Délai d'attente de connexion de 10 secondes, délai d'attente total de 30 secondes
curl -x http://proxy:8080 --connect-timeout 10 --max-time 30 http://example.com

# Dans wget
wget --timeout=30 --tries=3 -e http_proxy=http://proxy:8080 http://example.com

Gestion automatique des erreurs dans les scripts

Script pour le scraping avec basculement automatique vers le prochain proxy en cas d'erreur : 

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"

fetch_with_retry() {
    local url=$1
    local max_attempts=3
    
    for proxy in "${proxies[@]}"; do
        echo "Tentative via le proxy : $proxy"
        
        if curl -x "$proxy" \
                --connect-timeout 10 \
                --max-time 30 \
                -s -f "$url" -o output.html; then
            echo "Succès avec le proxy : $proxy"
            return 0
        else
            echo "Erreur avec le proxy : $proxy, essayons le suivant"
        fi
    done
    
    echo "Tous les proxies sont inaccessibles pour $url"
    return 1
}

# Utilisation
fetch_with_retry "http://example.com/page1"

Le paramètre -f oblige curl à renvoyer une erreur pour les statuts HTTP 4xx et 5xx, ce qui permet de gérer non seulement les erreurs réseau, mais aussi les blocages au niveau de l'application.

Journalisation pour le débogage

Conservez des journaux détaillés des requêtes pour analyser les problèmes : 

# Enregistrement des en-têtes de réponse
curl -x http://proxy:8080 -D headers.txt http://example.com

# Journal complet des interactions
curl -x http://proxy:8080 -v http://example.com 2>&1 | tee curl.log

# Seulement le statut HTTP
curl -x http://proxy:8080 -o /dev/null -s -w "%{http_code}\n" http://example.com

Scénarios pratiques d'utilisation

Examinons des tâches réelles où curl et wget avec des proxies résolvent des problèmes commerciaux spécifiques.

Scraping des prix des concurrents sur les marketplaces

Tâche : collecter les prix de 500 produits concurrents sur Wildberries pour analyser la stratégie de prix. Wildberries bloque activement les requêtes massives provenant d'une seule IP.

Solution : utilisation de proxies résidentiels avec rotation et randomisation du User-Agent : 

#!/bin/bash

# Proxy avec rotation automatique
PROXY="http://user:pass@rotating-residential.proxy.com:8080"

# Tableau User-Agent
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0"
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Safari/604.1"
)

# Lire les ID des produits à partir d'un fichier
while IFS= read -r product_id; do
    ua=${user_agents[$RANDOM % ${#user_agents[@]}]}
    
    curl -x "$PROXY" \
         -A "$ua" \
         -H "Accept-Language: ru-RU,ru;q=0.9" \
         -s "https://www.wildberries.ru/catalog/${product_id}/detail.aspx" \
         -o "products/${product_id}.html"
    
    echo "Produit $product_id téléchargé"
    sleep $((RANDOM % 5 + 3))  # Pause de 3-8 secondes
done < product_ids.txt

Surveillance de la disponibilité de l'API depuis différentes régions

Tâche : vérifier comment l'API de votre service fonctionne pour les utilisateurs de différents pays (géoblocages, temps de réponse).

Solution : proxies avec IP des pays nécessaires : 

#!/bin/bash

# Proxies de différents pays
declare -A proxies=(
    ["US"]="http://user:pass@us-proxy.com:8080"
    ["DE"]="http://user:pass@de-proxy.com:8080"
    ["JP"]="http://user:pass@jp-proxy.com:8080"
)

API_URL="https://api.yourservice.com/v1/status"

for country in "${!proxies[@]}"; do
    echo "Vérification depuis $country..."
    
    response_time=$(curl -x "${proxies[$country]}" \
                         -s -o /dev/null \
                         -w "%{time_total}" \
                         "$API_URL")
    
    http_code=$(curl -x "${proxies[$country]}" \
                     -s -o /dev/null \
                     -w "%{http_code}" \
                     "$API_URL")
    
    echo "$country : HTTP $http_code, temps de réponse ${response_time}s"
done

Téléchargement de fichiers via wget avec rotation des proxies

Tâche : télécharger une archive de fichiers (images de produits, documents) depuis un site qui limite la vitesse pour une seule IP. 

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current=0

while IFS= read -r file_url; do
    proxy="${proxies[$current]}"
    filename=$(basename "$file_url")
    
    echo "Téléchargement de $filename via le proxy #$current"
    
    wget --proxy-user=username --proxy-password=password \
         -e use_proxy=yes -e http_proxy="$proxy" \
         -O "downloads/$filename" \
         "$file_url"
    
    current=$(( (current + 1) % proxy_count ))
    sleep 2
done < file_urls.txt

Test des créatifs publicitaires dans différentes GEO

Tâche : vérifier à quoi ressemblent les annonces Facebook Ads pour les utilisateurs des États-Unis, du Canada et du Royaume-Uni (différentes devises, langues, disponibilité des offres). 

#!/bin/bash

# Proxies mobiles de différents pays pour plus de réalisme
declare -A mobile_proxies=(
    ["US"]="http://user:pass@us-mobile.proxy.com:8080"
    ["CA"]="http://user:pass@ca-mobile.proxy.com:8080"
    ["GB"]="http://user:pass@gb-mobile.proxy.com:8080"
)

AD_URL="https://www.facebook.com/ads/library/?id=YOUR_AD_ID"

for country in "${!mobile_proxies[@]}"; do
    curl -x "${mobile_proxies[$country]}" \
         -A "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Safari/604.1" \
         -H "Accept-Language: en-US,en;q=0.9" \
         -s "$AD_URL" \
         -o "ads_preview_${country}.html"
    
    echo "Aperçu enregistré pour $country"
done

Pour de telles tâches, les proxies mobiles sont particulièrement efficaces, car ils imitent de véritables utilisateurs de smartphones et suscitent moins de soupçons auprès des systèmes anti-fraude de Facebook.

Important pour les arbitragistes : Lors de la vérification des créatifs publicitaires via des proxies, utilisez des IP mobiles et les User-Agent correspondants des appareils mobiles. Facebook analyse la cohérence des données (le type d'appareil selon le User-Agent doit correspondre au type d'IP).

Automatisation de la vérification de la disponibilité du site

Tâche : surveiller la disponibilité de votre site toutes les 5 minutes, en imitant des requêtes de véritables utilisateurs (pas depuis une IP serveur). 

#!/bin/bash

PROXY="http://user:pass@residential.proxy.com:8080"
SITE_URL="https://yoursite.com"
LOG_FILE="uptime.log"

while true; do
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    http_code=$(curl -x "$PROXY" \
                     -s -o /dev/null \
                     -w "%{http_code}" \
                     --max-time 10 \
                     "$SITE_URL")
    
    if [ "$http_code" -eq 200 ]; then
        echo "[$timestamp] OK - HTTP $http_code" >> "$LOG_FILE"
    else
        echo "[$timestamp] ERROR - HTTP $http_code" >> "$LOG_FILE"
        # Envoi d'une alerte (par exemple, via l'API Telegram)
        curl -s "https://api.telegram.org/botTOKEN/sendMessage" \
             -d "chat_id=CHAT_ID&text=Site inaccessible : HTTP $http_code"
    fi
    
    sleep 300  # 5 minutes
done

Conclusion

Curl et wget sont des outils puissants pour automatiser les requêtes HTTP, et une configuration correcte des proxies les rend indispensables pour le scraping, la surveillance et les tests. Nous avons examiné tous les aspects clés : de la syntaxe de base aux scénarios avancés avec rotation IP, gestion des erreurs et randomisation des en-têtes.

Principales conclusions de l'article :

  • Utilisez le paramètre -x dans curl et les variables d'environnement pour configurer le proxy
  • Choisissez le type de proxy en fonction de la tâche : HTTP pour des requêtes simples, SOCKS5 pour plus de polyvalence
  • Remplacez toujours le User-Agent standard par un User-Agent de navigateur réaliste
  • Implémentez la rotation des proxies pour le scraping à grande échelle — c'est crucial pour contourner les blocages
  • Ajoutez la gestion des erreurs et des délais d'attente dans les scripts de production
  • Utilisez des pauses aléatoires entre les requêtes pour imiter le comportement humain

Pour les tâches nécessitant un haut niveau d'anonymat et un risque minimal de blocage (scraping des marketplaces, vérification des publicités, surveillance des concurrents), nous recommandons d'utiliser des proxies résidentiels. Ils ont des IP de véritables utilisateurs domestiques, ce qui rend vos requêtes indiscernables du trafic normal et réduit considérablement le risque d'être ajouté aux listes de blocage.

Vous disposez maintenant d'un ensemble complet d'outils et de connaissances pour travailler efficacement avec des proxies dans curl et wget. Appliquez ces techniques dans vos projets, adaptez les exemples à des tâches spécifiques et étendez l'automatisation sans craindre les blocages.