Contenu : Introduction · Préparation · Concepts de base · Étape 1 : Installation de Python et des bibliothèques · Étape 2 : Test rapide sans proxy · Étape 3 : Requête via un proxy mobile · Étape 4 : Rotation des IP · Étape 5 : Erreurs, timeouts et répétitions · Étape 6 : Gestion des captchas · Vérification du résultat · Erreurs fréquentes · Fonctionnalités avancées · FAQ · Conclusion

Introduction

Dans ce guide étape par étape, vous apprendrez à configurer un environnement Python, à envoyer des requêtes à des pages Web via des proxies mobiles, à parser des données avec BeautifulSoup et à gérer de manière sécurisée la rotation des IP. Nous utiliserons la bibliothèque requests pour les requêtes réseau et BeautifulSoup pour analyser le HTML. À la fin, vous disposerez d'un parseur minimal viable qui : envoie des requêtes HTTP via un proxy mobile, modifie correctement les en-têtes pour un appareil mobile, répète les requêtes avec un backoff intelligent en cas d'erreurs, fait tourner les IP côté fournisseur de proxies mobiles, gère soigneusement les captchas si jamais ils se présentent, et sauvegarde les données de manière pratique.

Pour qui ce guide : pour les débutants qui découvrent le scraping Web ; pour les professionnels d'autres domaines (marketing, recherche, OSINT) qui ont besoin d'un outil simple et fiable ; pour les développeurs qui souhaitent rapidement construire un prototype fonctionnel et l'améliorer par la suite.

Ce que vous devez savoir à l'avance : des compétences de base en informatique ; comprendre ce qu'est un fichier, un dossier et comment lancer l'invite de commande ; avoir une connaissance minimale de Python est un plus, mais ce n'est pas obligatoire, car nous avançons pas à pas. Important : vous devez avoir des bases légales pour traiter les pages cibles et respecter les règles des sites, y compris le fichier robots.txt et les conditions d'utilisation.

Temps nécessaire : 2 à 4 heures, si vous procédez étape par étape. L'installation de l'environnement et le test rapide prendront jusqu'à 30 minutes. La connexion du proxy mobile et la mise en place de la rotation prendront de 40 minutes à 1,5 heure. Ajouter la gestion des erreurs et des captchas prendra de 30 à 60 minutes.

Conseil : Conservez le lien vers la section Étape 4 : Rotation des IP et Étape 5 : Erreurs, timeouts et répétitions. Ces blocs sont souvent nécessaires pour le débogage et l'amélioration de la stabilité.

⚠️ Attention : Tout le contenu est fourni à des fins d'apprentissage et de pratique du parsing légal. N'utilisez pas ces techniques pour contourner les restrictions d'accès, ne violez pas la législation et les conditions d'utilisation des sites. Nous ne discutons pas non plus des VPN ou d'autres méthodes pour contourner les blocages.

Préparation

Outils et accès nécessaires : un ordinateur avec Windows, macOS ou Linux ; un accès à Internet ; Python 3.11–3.13 installé (nous recommandons la version actuelle) ; un gestionnaire de packages pip ; un éditeur de texte (Visual Studio Code, PyCharm Community ou tout autre). Vous aurez également besoin d'un compte chez un fournisseur de proxy mobile. Pour cela, vous pouvez vous baser sur les exigences fonctionnelles fournies par des services tels que mobileproxy.space : un endpoint proxy séparé, une autorisation par nom d'utilisateur et mot de passe ou par IP, une rotation configurable (par minuteur ou par API), des statistiques sur les requêtes.

Exigences système : au moins 4 Go de RAM ; 1 à 2 Go d'espace libre sur le disque pour Python et les bibliothèques ; une connexion Internet stable d'au moins 10 Mbit/s ; possibilité d'installer des programmes. Les droits d’administrateur sont nécessaires uniquement pour l'installation de Python (sur Windows).

Ce qu'il faut télécharger et installer : l'installateur Python ; un éditeur de code (par exemple, VS Code) ; les bibliothèques requests, beautifulsoup4, lxml (pour un parsing HTML accéléré).

Création de sauvegardes (si nécessaire) : avant de modifier des projets existants, créez une copie du dossier contenant le code. Si vous créez un projet pour la première fois, créez un répertoire de travail distinct. Conservez le fichier contenant les accès au proxy en dehors du dépôt et, si possible, utilisez un fichier .env et un gestionnaire de secrets.

Conseil : Créez un dossier de projet sans espaces et sans cyrillique dans le nom, par exemple parser_mobile_proxy. Cela facilitera l'exécution des scripts et évitera les erreurs de chemin.

Concepts de base

Termes clés expliqués simplement : le parsing ou scraping Web est la collecte automatique de données publiquement accessibles sur les pages d'un site. requests est une bibliothèque Python pour exécuter des requêtes HTTP. BeautifulSoup est une bibliothèque Python pour analyser le HTML et extraire des fragments de contenu par balises, classes ou attributs. Un proxy est un serveur intermédiaire qui envoie la requête au site en son nom. Un proxy mobile utilise des adresses IP de fournisseurs mobiles. La rotation des IP est le changement de l'IP sortante à intervalles réguliers ou sur demande.

Principes de base : vous formez une requête HTTP au site ; votre requête passe par le proxy mobile ; le site voit l'adresse du proxy et non la vôtre. Vous recevez la page HTML et l'analysez avec BeautifulSoup.

Ce qu'il est important de comprendre avant de commencer : respectez le fichier robots.txt et les conditions du site ; ne surchargez pas le serveur avec des requêtes fréquentes ; utilisez des timeouts ; envoyez un nombre raisonnable de requêtes parallèles ; gérez les codes de réponse 4xx et 5xx. Un proxy mobile aide à réduire la probabilité de déclencheurs de fraude et de restrictions, car les plages d'adresses mobiles sont souvent utilisées par de vrais utilisateurs. La stabilité dépend également de la qualité du fournisseur, de la charge et de la précision de votre code.

⚠️ Attention : N'utilisez pas le parsing pour contourner l'authentification ou accéder à des sections fermées sans permission. Ne tentez pas d'interférer avec le fonctionnement du site. Ne travaillez qu'avec des données ouvertes sur lesquelles vous avez des droits de traitement.

Étape 1 : Installation de Python et des bibliothèques

Objectif de l'étape

Installer Python et les bibliothèques nécessaires, créer un projet et des fichiers de base. Après cette étape, vous pourrez exécuter des scripts et soumettre des requêtes HTTP.

Instructions étape par étape

  1. Téléchargez et installez Python à partir du site officiel. Lors de l'installation sur Windows, cochez la case Ajouter Python au PATH. Sur macOS, vous pouvez utiliser le gestionnaire de packages brew ou l'installateur officiel. Sur Linux, utilisez les dépôts de votre système.
  2. Vérifiez l'installation. Ouvrez le terminal et exécutez la commande : python --version ou python3 --version. Assurez-vous que la version est comprise entre 3.11 et 3.13.
  3. Créez le dossier du projet, par exemple C:\Users\votre_utilisateur\parser_mobile_proxy ou /Users/votre_utilisateur/parser_mobile_proxy.
  4. Ouvrez le dossier du projet dans votre éditeur de code. Créez le fichier main.py et le fichier requirements.txt.
  5. Ajoutez dans requirements.txt : requests==2.32.3 ; beautifulsoup4==4.12.3 ; lxml==5.2.2.
  6. Installez les dépendances avec la commande pip install -r requirements.txt ou pip3 install -r requirements.txt.
  7. Vérifiez que les bibliothèques sont installées. Dans le terminal, exécutez python -c "import requests, bs4, lxml; print('ok')". Cela devrait afficher ok.

Points importants

Important : Installez les bibliothèques dans un environnement virtuel pour éviter les conflits de versions. Vous pouvez créer cet environnement avec la commande python -m venv .venv et l'activer avec source .venv/bin/activate (macOS, Linux) ou .venv\Scripts\activate (Windows), puis exécuter pip install -r requirements.txt.

Conseil : Si vous n'avez pas les droits d'administrateur, utilisez une installation utilisateur pip install --user -r requirements.txt ou travaillez dans un environnement virtuel.

Résultat attendu

Vous pouvez lancer un script simple et importer les modules nécessaires sans erreurs.

Problèmes possibles et solutions

  • La commande python n'est pas trouvée. Solution : utilisez python3 ou assurez-vous que le PATH est correctement configuré. Réinstallez Python en incluant l'option Ajouter au PATH.
  • Conflit de versions lxml. Solution : mettez à jour pip (python -m pip install --upgrade pip), puis réinstallez lxml.
  • Manque de droits lors de l'installation. Solution : activez l'environnement virtuel ou utilisez le flag --user.

✅ Vérification : La commande python -c "import requests, bs4; print('ready')" renvoie ready, et le fichier main.py existe dans le dossier du projet.

Étape 2 : Test rapide de parsing sans proxy

Objectif de l'étape

Comprendre que la combinaison de base requests + BeautifulSoup fonctionne avant de connecter le proxy. Nous ferons une requête normale à une page de test et extrairons le titre.

Instructions étape par étape

  1. Ouvrez le fichier main.py dans l'éditeur.
  2. Insérez le code de base pour la requête et le parsing.
  3. Lancez le script et vérifiez la sortie.

Code d'exemple

import requests; from bs4 import BeautifulSoup; session = requests.Session(); session.headers.update({"User-Agent": "Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0 Mobile Safari/537.36"}); url = "https://example.com"; resp = session.get(url, timeout=30); html = resp.text; soup = BeautifulSoup(html, "lxml"); title = soup.title.text.strip() if soup.title else "(pas de balise title)"; print("Statut :", resp.status_code, "Titre :", title)

Points importants

Important : Nous utilisons un User-Agent mobile pour imiter un navigateur mobile. Cela aidera à harmoniser le comportement avec le proxy mobile à l'étape suivante.

Conseil : Si la page cible peut renvoyer une version différente pour desktop et mobile, sauvegardez le HTML dans un fichier pour le débogage : open("page.html", "w", encoding="utf-8").write(html). Ainsi, vous pourrez étudier la structure des balises.

Résultat attendu

Le script imprime le code de réponse et le titre de la page. C'est une vérification de base pour voir que le parseur peut voir et analyser le HTML.

Problèmes possibles et solutions

  • Code 403 ou 404. Solution : vérifiez l'URL ; essayez de changer le User-Agent ; assurez-vous que le site est accessible.
  • Timeout. Solution : augmentez le timeout à 60, vérifiez la connexion Internet.
  • Mauvaise encodage. Solution : utilisez resp.encoding = resp.apparent_encoding avant le parsing.

✅ Vérification : Vous voyez le statut 200 et la ligne Titre : (nom de la page). Le fichier page.html peut apparaître dans le dossier si vous avez sauvegardé le HTML.

Étape 3 : Requête via un proxy mobile

Objectif de l'étape

Connecter le proxy mobile à requests, envoyer une requête et s'assurer que le trafic passe bien par le proxy et non directement. Nous ajouterons également une authentification et vérifierons les en-têtes.

Ce qu'il faut préparer

Les données de votre proxy mobile : hôte (par exemple, proxy.provider.local ou adresse IP), port (par exemple, 12345), nom d'utilisateur et mot de passe pour l'authentification, ou liste blanche IP confirmée si le fournisseur autorise par adresse IP. La plupart des fournisseurs mobiles, y compris des solutions comme mobileproxy.space, fournissent ces paramètres dans leur interface utilisateur.

Instructions étape par étape

  1. Ouvrez le fichier main.py.
  2. Ajoutez un dictionnaire proxies avec les données de votre proxy.
  3. Envoyez la requête via session.get avec le paramètre proxies.
  4. Vérifiez que la réponse est bien reçue et parsez la page.

Code d'exemple

import requests; from bs4 import BeautifulSoup; PROXY_HOST = "PROXY_HOST"; PROXY_PORT = 12345; PROXY_USER = "USER"; PROXY_PASS = "PASS"; proxy_auth = f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}"; proxies = {"http": proxy_auth, "https": proxy_auth}; session = requests.Session(); session.headers.update({"User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1", "Accept-Language": "fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7"}); url = "https://example.com"; resp = session.get(url, proxies=proxies, timeout=45); print("HTTP :", resp.status_code); soup = BeautifulSoup(resp.text, "lxml"); print("TITRE :", soup.title.text.strip() if soup.title else "(pas)")

Points importants

Important : Si votre fournisseur utilise une authentification par adresse IP, utilisez le format proxies sans nom d'utilisateur et mot de passe : "http": f"http://{PROXY_HOST}:{PROXY_PORT}". Assurez-vous que votre IP actuelle est ajoutée à la liste blanche dans le tableau de bord du fournisseur.

Conseil : Lors de votre première exécution, ajoutez le paramètre verify=False uniquement pour diagnostiquer les erreurs TLS. Ne laissez pas cela en production. Il est préférable d'installer les certificats racines si cela est exigé par le fournisseur.

Conseil : Conservez les réglages du proxy dans un fichier .env : PROXY_HOST, PROXY_PORT, PROXY_USER, PROXY_PASS. Chargez-les via os.getenv ou la bibliothèque python-dotenv pour ne pas stocker de secrets dans le code.

Résultat attendu

Vous obtenez un code 200 et un TITRE correct. Si la page cible affiche l'IP, celle-ci devrait être différente de la vôtre, car la requête passe par le proxy mobile.

Problèmes possibles et solutions

  • 407 Proxy Authentication Required. Solution : vérifiez le nom d'utilisateur et le mot de passe ; assurez-vous que vous utilisez le bon format d'URL avec l'authentification.
  • 403 Forbidden. Solution : changez le User-Agent pour un mobile ; vérifiez les en-têtes Accept-Language ; réduisez la fréquence des requêtes.
  • ConnectionError ou ReadTimeout. Solution : augmentez le timeout, vérifiez la stabilité du proxy chez le fournisseur, réessayez la requête avec un backoff.

✅ Vérification : La réponse arrive avec un statut 200. Le TITRE est correct. Si vous testez sur une page qui montre votre IP, elle devrait correspondre à celle du proxy mobile (voir le tableau de bord du fournisseur).

Étape 4 : Rotation des adresses IP de manière sécurisée et prévisible

Objectif de l'étape

Configurer le changement d'IP du proxy mobile par minuteur ou par une commande API. Cela améliore la résistance du parsing et réduit les chances d'être soumis à des restrictions de protection. Nous mettrons en œuvre deux méthodes : une liste circulaire d'endpoints proxy et une rotation au sein d'un même endpoint via l'API ou le minuteur du fournisseur.

Instructions étape par étape

  1. Dressez votre stratégie de rotation : par temps (par exemple, toutes les 5 à 10 minutes), par nombre de requêtes (par exemple, après chaque 10 à 20 requêtes) ou hybride.
  2. Si vous avez plusieurs endpoints proxy, préparez une liste et implémentez un switch round-robin.
  3. Si le fournisseur possède une API de changement d'IP pour un seul endpoint, ajoutez cet appel dans le code et attendez la fenêtre de rotation confirmée (généralement entre 10 et 60 secondes).
  4. Considérez les limitations du fournisseur : l'intervalle minimal de rotation et le nombre d'appels API par jour.
  5. Intégrez des pauses et vérifiez l'IP après la rotation pour vous assurer que la nouvelle IP est active.

Exemple de round-robin avec plusieurs endpoints

import itertools, requests; from bs4 import BeautifulSoup; proxies_list = [ {"http": "http://user1:pass1@host1:10001", "https": "http://user1:pass1@host1:10001"}, {"http": "http://user2:pass2@host2:10002", "https": "http://user2:pass2@host2:10002"} ]; cycle = itertools.cycle(proxies_list); def fetch(url): s = requests.Session(); s.headers.update({"User-Agent": "Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Mobile Safari/537.36"}); proxies = next(cycle); r = s.get(url, proxies=proxies, timeout=45); return r; r = fetch("https://example.com/catalog"); print(r.status_code)

Exemple de rotation dans un même endpoint via API

De nombreux fournisseurs de proxies mobiles, y compris ceux de classe mobileproxy.space, permettent de changer d'IP dans un même endpoint par minuteur (par exemple, toutes les N minutes) ou sur demande via l'API. Dans le code, cela ressemble à une requête supplémentaire à l'URL de service du fournisseur. Voici un modèle général. Remplacez l'URL et le token par les vôtres provenant du tableau de bord du fournisseur. Prenez en compte les limites et les fenêtres de rotation.

import time, requests; def rotate_ip(api_rotate_url, timeout=30): try: r = requests.get(api_rotate_url, timeout=timeout); return r.status_code, r.text; except Exception as e: return None, str(e); api_url = "http://PROXY_HOST:PORT/changeip?token=YOUR_TOKEN"; status, body = rotate_ip(api_url); print("ROTATE :", status, body); time.sleep(20); # attendez la fenêtre de rotation ; s = requests.Session(); proxies = {"http": "http://USER:PASS@PROXY_HOST:PORT", "https": "http://USER:PASS@PROXY_HOST:PORT"}; resp = s.get("https://example.com", proxies=proxies, timeout=45); print(resp.status_code)

Points importants

Important : La rotation n'est pas une solution miracle. Si vous effectuez trop de requêtes en peu de temps, les déclencheurs de protection peuvent s'activer même avec un changement d'IP. Maintenez une fréquence modérée, utilisez des retards aléatoires et des répétitions avec un backoff.

Conseil : Planifiez la rotation par heure et par charge. Par exemple, effectuer une rotation toutes les 10 à 20 minutes ainsi qu'après 15 à 25 requêtes sur un domaine. Cela lisse le comportement et semble naturel.

Conseil : Conservez des métadonnées de chaque requête : quel proxy a été utilisé, quelle était l'IP, quel statut a renvoyé le serveur. Cela accélérera le débogage.

Résultat attendu

Votre code change de manière stable les endpoints proxy ou initie un changement d'IP dans un même endpoint et attend la fenêtre de rotation. Après le changement, les requêtes continuent à être exécutées avec un statut 200.

Problèmes possibles et solutions

  • IP ne change pas après l'appel à l'API. Solution : attendez plus longtemps, vérifiez les limites ; assurez-vous que vous appelez la bonne URL et que le token est valide ; consultez les statistiques dans le tableau de bord du fournisseur.
  • Panne d'accessibilité au moment de la rotation. Solution : pendant la rotation, passez à un autre endpoint, utilisez un canal de secours dans le round-robin.
  • Fréquemment 429 Too Many Requests. Solution : augmentez l'intervalle entre les requêtes, réduisez le nombre total de threads simultanés.

✅ Vérification : En affichant régulièrement l'IP actuelle dans les logs, vous verrez que l'adresse change conformément à la stratégie de rotation, et le statut des requêtes reste entre 200 et 299.

Étape 5 : Gestion des erreurs, timeouts et répétitions

Objectif de l'étape

Rendre votre parseur résistant aux pannes réseau et aux erreurs temporaires du serveur. Nous ajouterons des timeouts, des répétitions avec un backoff exponentiel, des délais aléatoires et du logging.

Instructions étape par étape

  1. Définissez un nombre maximum de répétitions (par exemple, 3 à 5) et un délai de base (par exemple, 1 à 2 secondes).
  2. Implémentez un backoff : pour chaque échec, augmentez l'attente par un facteur de 2 plus un peu de bruit aléatoire.
  3. Capturez les codes 5xx et 429 comme temporaires, gérez 4xx avec précaution (403 est souvent un blocage permanent).
  4. Ajoutez des logs clairs pour comprendre ce qui se passe à chaque étape.
  5. Encapsulez l'appel réseau dans une fonction fetch_safely, facilement réutilisable.

Code d'exemple

import time, random, requests; from bs4 import BeautifulSoup; def fetch_safely(url, session, proxies=None, max_retries=4, base_delay=1.5, timeout=45): attempt = 0; while attempt <= max_retries: try: r = session.get(url, proxies=proxies, timeout=timeout); if r.status_code in (200, 201): return r; elif r.status_code in (429, 500, 502, 503, 504): delay = base_delay * (2 ** attempt) + random.uniform(0.0, 0.7); time.sleep(delay); attempt += 1; continue; elif r.status_code == 403: return r; else: return r; except (requests.exceptions.ConnectTimeout, requests.exceptions.ReadTimeout, requests.exceptions.ConnectionError) as e: delay = base_delay * (2 ** attempt) + random.uniform(0.1, 0.9); time.sleep(delay); attempt += 1; continue; return None

Points importants

Important : Établissez des timeouts raisonnables : 30 à 60 secondes pour des canaux instables, 10 à 20 secondes pour un réseau rapide. Ne désactivez pas la vérification SSL, sauf si c'est absolument nécessaire.

Conseil : Utilisez le module logging pour les logs. Au démarrage, ajoutez une configuration minimale : logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s"). Cela facilite le diagnostic.

Conseil : Séparez les « pannes temporaires » des « échecs permanents ». Les temporaires sont à réessayer ; les permanents sont à consigner et à oublier pour ne pas rester coincé.

Résultat attendu

Le script continue à fonctionner en cas d'erreurs temporaires et renvoie une réponse, ou passe correctement à la tâche suivante sans échec.

Problèmes possibles et solutions

  • Les répétitions ne fonctionnent pas, se terminent toujours par 429. Solution : réduisez la fréquence des demandes, allongez les délais, augmentez la fenêtre entre les rotations IP.
  • 403 permanents. Solution : clarifiez la politique du site, vérifiez la validité des en-têtes, réduisez la fréquence, et si nécessaire, utilisez les API officielles.
  • Fréquemment des ConnectionError. Solution : vérifiez le fournisseur de proxies mobiles ; il se peut qu'un autre région ou port soit nécessaire.

✅ Vérification : En simulant des pannes, vous verrez dans les logs des répétitions avec des délais croissants. Après 1 à 2 tentatives, de nombreuses requêtes s'achèvent avec succès.

Étape 6 : Détection et gestion des captchas de manière légale

Objectif de l'étape

Apprendre à reconnaître quand une page renvoie un captcha et à réagir correctement : diminuer la charge, suspendre temporairement les requêtes, utiliser correctement la rotation IP. Nous ne contournons pas les protections, mais agissons dans le cadre d'un scraping éthique.

Instructions étape par étape

  1. Identifiez les signes d'un captcha sur les sites cibles : présence de mots-clés dans le HTML (captcha, g-recaptcha), formulaires avec des champs inhabituels, pages d'alerte.
  2. Ajoutez dans le code une vérification du contenu HTML avant le parsing de la logique principale.
  3. En cas de captcha, agissez doucement : augmenter la pause ; diminuer la fréquence sur le domaine ; initier la rotation IP ; tentez une nouvelle requête.
  4. Si le captcha persiste, cessez les tentatives automatiques et examinez les conditions d'utilisation du site. Il se peut que les données soient accessibles via une API officielle.

Code d'exemple

from bs4 import BeautifulSoup; import time, requests; def is_captcha(html): text = html.lower(); hints = ["captcha", "g-recaptcha", "hcaptcha", "distil", "cloudflare", "please verify", "are you a human"]; return any(h in text for h in hints); def get_with_captcha_handling(url, session, proxies, rotate_func=None): r = session.get(url, proxies=proxies, timeout=45); if r.status_code == 200 and not is_captcha(r.text): return r; time.sleep(10); if rotate_func: try: rotate_func(); time.sleep(20); except Exception: pass; r2 = session.get(url, proxies=proxies, timeout=60); return r2

Points importants

Important : Si le captcha continue de réapparaître, réduisez l'intensité du scan, attendez la prochaine fenêtre de rotation ou changez d'endpoint. Respectez l'éthique et les règles du site.

Conseil : Parfois, les captchas ne s'affichent que pour certains chemins. Réduisez la fréquence uniquement pour ces chemins, et non pour tout le domaine. Cela préserve la vitesse globale.

⚠️ Attention : Nous ne discutons pas de contournements de captcha utilisant des services tiers, des scripts de contournement, d'émulation de navigateur et techniques similaires. Travaillez uniquement dans les cadres autorisés, utilisez des API officielles si disponibles.

Résultat attendu

Le script doit pouvoir réagir doucement à l'apparition du captcha : faire une pause, initier le changement d'IP (si disponible) et réessayer la requête. Cela réduit le nombre de faux échecs et contribue à maintenir la stabilité.

Problèmes possibles et solutions

  • Captcha à chaque requête. Solution : réduisez drastiquement la fréquence, utilisez des intervalles différents entre les requêtes, changez le fuseau horaire ou la région du proxy auprès du fournisseur (si disponible), examinez le robots.txt.
  • Captcha disparaît mais les données sont instables. Solution : augmentez le timeout, conservez et analysez le HTML, comparez les versions de pages pour différentes IP.

✅ Vérification : En déclenchant artificiellement un captcha (par exemple, des requêtes fréquentes en peu de temps), vous verrez dans les logs des pauses et des rotations, suivies de réponses réussies sans captcha.

Vérification du résultat

Checklist

  • Python est installé et les dépendances sont correctement mises en place.
  • Le script sans proxy obtient le HTML et parse le titre.
  • Le script avec proxy mobile retourne le statut 200.
  • La rotation des IP est activée et vérifiée.
  • Les répétitions en cas d'erreurs fonctionnent et les timeouts sont réglés.
  • Il y a gestion des signes de captcha.
  • Les données sont sauvegardées dans un fichier ou affichées dans la console comme prévu.

Comment procéder au test

  1. Lancez une requête basique sans proxy et assurez-vous que le parsing du titre fonctionne.
  2. Activez le proxy et répétez la requête, puis comparez les résultats.
  3. Appelez le changement d'IP chez le fournisseur (si disponible) et répétez la requête après 20 à 60 secondes.
  4. Réduisez artificiellement le timeout à 1 à 2 secondes et vérifiez que les répétitions avec backoff s'activent et reviennent ensuite à la normale lorsque le timeout est rétabli.
  5. Chargez le site avec plusieurs requêtes successives et assurez-vous qu'à l'apparition de signes de captcha, des pauses sont respectées et, si nécessaire, que la rotation se déclenche.

Indicateurs de réussite

  • Taux de requêtes réussies supérieur à 90 % sur des sites « calmes ».
  • Les codes 429 et 5xx apparaissent rarement et sont gérés par des répétitions.
  • La rotation IP se fait selon le mode défini, sans longues interruptions.

Conseil : Introduisez des métriques telles que « temps de réponse » et « nombre de répétitions » et enregistrez-les dans les logs. Cela aidera à comprendre quand ajuster la stratégie de rotation ou la fréquence des requêtes.

Erreurs fréquentes et solutions

  • Problème : 407 Proxy Authentication Required. Raison : nom d'utilisateur ou mot de passe incorrects, URL du proxy mal formée. Solution : vérifiez le format http://USER:PASS@HOST:PORT, assurez-vous qu'il n'y a pas de caractères ou d'espaces superflus ; si l'autorisation est par IP, retirez le nom d'utilisateur et le mot de passe.
  • Problème : 403 Forbidden. Raison : protection du site activée, User-Agent inapproprié ou requêtes trop fréquentes. Solution : utilisez un User-Agent mobile, réduisez la fréquence, activez la rotation IP, vérifiez Accept, Accept-Language et Referer.
  • Problème : 429 Too Many Requests. Raison : limite de fréquence dépassée. Solution : ajoutez un backoff exponentiel, augmentez les pauses, réduisez la fréquence de rotation, répartissez les requêtes sur les heures de la journée.
  • Problème : ConnectionError ou ReadTimeout. Raison : canal proxy instable ou réseau saturé. Solution : augmentez le timeout, réessayez avec un backoff, utilisez un endpoint de secours.
  • Problème : parsing incorrect, données vides. Raison : structure HTML modifiée ou contenu chargé via JavaScript. Solution : mettez à jour les sélecteurs BeautifulSoup ; si les données sont générées dynamiquement, examinez les requêtes réseau de la page et utilisez leurs JSON endpoints officiels si disponibles et si autorisé.
  • Problème : captcha sur chaque page. Raison : charge agressive ou activité suspecte. Solution : réduisez la fréquence, augmentez les pauses, utilisez la rotation, vérifiez la validité des en-têtes et le respect du robots.txt.
  • Problème : blocage après plusieurs requêtes réussies. Raison : comportement prévisible du script. Solution : introduisez des délais aléatoires, variez l'ordre des requêtes, alternez les proxies et mettez à jour les en-têtes.

Conseil : Conservez des exemples HTML avant et après un incident. Cela aidera à distinguer rapidement un changement de mise en page des signes de protection anti-bot.

Fonctionnalités avancées

Paramètres avancés

  • Séances et cookies : utilisez requests.Session pour gérer les cookies automatiquement, ce qui rapproche le comportement d’un véritable navigateur.
  • En-têtes : ajoutez Accept, Accept-Language, Referer et DNT si nécessaire. Changez le User-Agent à partir d'un pool d’agents mobiles.
  • Proxys SOCKS : connectez requests[socks] si nécessaire. Cependant, les proxies mobiles sont souvent fournis sous forme HTTP(S).
  • Sauvegarde en CSV ou JSON : après parsing, enregistrez les données dans des fichiers. Cela facilite les intégrations.

Exemple de mini pipeline de parsing

import csv, requests, time; from bs4 import BeautifulSoup; MOBILE_UA = "Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Mobile Safari/537.36"; session = requests.Session(); session.headers.update({"User-Agent": MOBILE_UA}); proxies = {"http": "http://USER:PASS@HOST:PORT", "https": "http://USER:PASS@HOST:PORT"}; urls = ["https://example.com/page1", "https://example.com/page2"]; rows = []; for u in urls: r = session.get(u, proxies=proxies, timeout=45); if r.status_code == 200: s = BeautifulSoup(r.text, "lxml"); title = s.title.text.strip() if s.title else ""; rows.append({"url": u, "title": title}); time.sleep(2); open("data.csv", "w", newline="", encoding="utf-8"); with open("data.csv", "w", newline="", encoding="utf-8") as f: w = csv.DictWriter(f, fieldnames=["url","title"]); w.writeheader(); w.writerows(rows); print("sauvé :", len(rows))

Optimisation

  • Traitement par lot : regroupez les requêtes par domaine en tenant compte des délais et des rotations.
  • Mise en cache : conservez localement les pages déjà obtenues pour ne pas les demander à nouveau inutilement.
  • Stratégie de temporisation : planifiez les heures de requêtes durant les heures « creuses » où le site est moins chargé.

Conseil : Si vous avez de nombreuses tâches, divisez-les en petites vagues et exécutez-les successivement. Cela augmente la stabilité et réduit la probabilité de captchas.

Conseil : De nombreux fournisseurs de proxies mobiles (y compris les offres de niveau mobileproxy.space) ont un tableau de bord intuitif avec des statistiques visibles. Comparez le temps, la fréquence et les codes de réponse – cela donne une idée de quand faire une rotation.

FAQ

Question : Comment vérifier qu'une requête passe bien par un proxy mobile ? Réponse : Consultez dans le tableau de bord du fournisseur les connexions actives et votre IP externe actuelle, comparez-la avec ce que vous voyez dans les réponses de la page. Le fournisseur montre généralement des statistiques sur les requêtes à l'endpoint.

Question : Comment choisir un User-Agent : Android ou iOS ? Réponse : Choisissez la plateforme sur laquelle tourne votre contenu (version mobile du site). Souvent, l'agent Android donne un résultat prévisible. Testez les deux et enregistrez où il y a le moins de refus.

Question : À quelle fréquence changer d'IP en cas de parsing ? Réponse : Recommandation de base : pas plus souvent qu'une fois toutes les 10 à 20 minutes, ou après 15 à 25 requêtes sur un domaine. Adaptez cela en fonction de la charge, évitez les changements de rotation fréquents.

Question : Que faire si le site renvoie du contenu via JavaScript ? Réponse : Examinez les requêtes réseau de la page (dans les outils de développement du navigateur). Souvent, les données arrivent via des endpoints JSON. Si l'accès est légal et ne viole pas les conditions, utilisez ces endpoints. Sinon, consultez les règles du site.

Question : Peut-on utiliser plusieurs fournisseurs mobiles en même temps ? Réponse : Oui, si nécessaire pour répartir la charge. Mettez en place un round-robin et surveillez les limites de chaque fournisseur.

Question : Comment stocker les informations d'identification en toute sécurité ? Réponse : Utilisez des variables d'environnement et un fichier .env, ne commitez pas de secrets dans le dépôt. En production, conservez les secrets dans des gestionnaires de secrets.

Question : Comment arrêter correctement le script en cas de nombreuses erreurs ? Réponse : Introduisez un compteur d'échecs et une limite supérieure. Si N requêtes sur un domaine échouent, faites une longue pause, enregistrez l'incident et terminez le processus.

Question : A-t-on besoin de lxml si on a le parser intégré html.parser ? Réponse : Le parser intégré convient pour des cas simples. lxml est plus rapide et plus résistant au HTML partiellement incorrect. Pour un parsing régulier, lxml est recommandé.

Question : Que faire si le site change de mise en page ? Réponse : Conservez des pages de test, ajoutez des vérifications de régression sur les sélecteurs. Lorsqu'il y a des changements, ajustez la logique de BeautifulSoup et écrivez des fonctions adaptées à la nouvelle structure.

Question : Pourquoi ai-je besoin d'un proxy mobile si un proxy normal fonctionne aussi ? Réponse : Les adresses mobiles suscitent souvent moins de suspicion compte tenu des particularités des réseaux mobiles et de la répartition du trafic. Cela augmente les chances d'obtenir des réponses stables avec une charge raisonnable.

Conclusion

Résumé des actions entreprises : vous avez installé Python et les bibliothèques requests et BeautifulSoup, vérifié le parsing de base sans proxy, ajouté un proxy mobile et confirmé que les requêtes passent par lui, configuré la rotation IP de plusieurs façons, intégré la gestion des erreurs et réagi correctement aux captchas. Vous disposez désormais d'un projet de base pour un scraping public de données stable et éthique.

Prochaines étapes : développez le parseur selon vos objectifs — ajoutez de nouveaux sélecteurs, enregistre les données dans une base, configurez un calendrier d'exécution. Incluez des alertes en cas de chute du taux de requêtes réussies ou d'augmentation des statuts 429 et 403. Ajoutez un fichier de configuration pour les paramètres de gestion (fréquence, rotation, timeouts).

Perspectives d'avenir : explorez les requêtes asynchrones avec Python (aiohttp), les files d'attente de tâches (Celery, RQ), le stockage et l'analyse de données (SQLite, PostgreSQL, Pandas). Examinez également les aspects juridiques du traitement des données et des interactions avec les sites, ainsi que l'accès officiel aux données via des APIs légales. Pour les proxies mobiles, utilisez des fonctionnalités similaires à celles fournies par des services modernes comme mobileproxy.space : rotation flexible, statistiques, différents régions et support stable.

Conseil : Sauvegardez ce guide et retournez souvent aux sections Étape 4 : Rotation des IP et Étape 5 : Erreurs, timeouts et répétitions. Elles offrent une stabilité essentielle et aident à éviter les interruptions.

⚠️ Attention : Vérifiez toujours le robots.txt et les conditions d'utilisation des sites cibles. Si les règles interdisent la collecte automatisée de données, respectez les interdictions et recherchez des alternatives légales, comme les APIs ouvertes ou payantes.