Comment diagnostiquer la cause d'un taux de succès faible : guide étape par étape

Le taux de succès est le pourcentage de requêtes réussies par rapport au nombre total de tentatives. Lorsque cet indicateur baisse en dessous de la normale, vous perdez de l'argent, du temps et des données. Mais les causes peuvent être nombreuses : d'une mauvaise configuration à des blocages du serveur cible. Dans cet article, nous examinerons une approche systématique du diagnostic et trouverons une solution.

Qu'est-ce que le taux de succès et quelle est la norme

Taux de succès (SR) = (Requêtes réussies / Nombre total de requêtes) × 100%

Les valeurs normales dépendent du type de tâche :

Si le SR baisse de 5 à 10% par rapport à votre ligne de base, c'est un signal pour diagnostiquer. S'il baisse de 20%+, des actions urgentes sont nécessaires.

Premières étapes du diagnostic

Étape 1 : Vérifiez les journaux et les métriques

Collectez les données des 24 à 72 dernières heures :

• Quand exactement le SR a-t-il baissé ? (heure exacte)
• Quel pourcentage de requêtes retourne l'erreur 407 (Authentification proxy requise) ?
• Quel pourcentage retourne 429 (Trop de requêtes) ?
• Quel pourcentage retourne des délais d'attente (délai de connexion) ?
• La charge a-t-elle changé (RPS - requêtes par seconde) ?

Étape 2 : Testez isolément

Utilisez un simple script pour vérifier le proxy sans votre application :

import requests
import time

proxy = "http://proxy_ip:port"
proxies = {"http": proxy, "https": proxy}
target_url = "https://httpbin.org/ip"

success = 0
failed = 0

for i in range(100):
    try:
        response = requests.get(
            target_url, 
            proxies=proxies, 
            timeout=10,
            verify=False
        )
        if response.status_code == 200:
            success += 1
            print(f"✓ Tentative {i+1}: succès")
        else:
            failed += 1
            print(f"✗ Tentative {i+1}: statut {response.status_code}")
    except Exception as e:
        failed += 1
        print(f"✗ Tentative {i+1}: {str(e)}")
    time.sleep(0.5)

sr = (success / (success + failed)) * 100
print(f"\nTaux de succès : {sr:.1f}%")
print(f"Réussi : {success}, Erreurs : {failed}")

Si ce test montre un SR normal, le problème se trouve dans votre code ou votre configuration. Si le SR est faible même ici, le problème se trouve dans le proxy ou le serveur cible.

Problèmes du côté du proxy

Erreur 407 : Authentification proxy requise

Causes :

• Identifiants incorrects (nom d'utilisateur/mot de passe)
• Compte expiré
• Adresse IP non dans la liste blanche (si requise)
• La rotation IP ne fonctionne pas ou est désactivée

Solution :

import requests

# Format correct pour les proxies résidentiels
proxy = "http://login:password@proxy-host:port"
proxies = {"http": proxy, "https": proxy}

# Test
response = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)
print(response.text)

Surcharge du serveur proxy

Si tous les utilisateurs du service envoient un grand nombre de requêtes simultanément, il peut y avoir une limitation par RPS (requêtes par seconde). C'est rare, mais cela arrive.

Vérifiez :

• Votre RPS actuel au pic
• Les limites de votre forfait
• S'il y a des erreurs 429 dans les journaux

Solution : ajoutez un délai entre les requêtes ou mettez à jour votre forfait.

Qualité des adresses IP

Pour les proxies résidentiels, un SR faible peut signifier que vous recevez des adresses bloquées. Vérifiez :

• Quel pourcentage d'adresses IP retourne 403 Accès interdit ?
• Les mêmes adresses se répètent-elles ?
• Y a-t-il un motif - un pays/région fonctionne, un autre non ?

Blocages et filtres du serveur cible

Erreur 429 : Trop de requêtes

Le serveur cible voit trop de requêtes depuis une seule IP ou en général. Solutions :

• Ajoutez un délai : `time.sleep(random.uniform(1, 3))`
• Utilisez la rotation IP : chaque requête - une nouvelle IP
• Réduisez le RPS : envoyez les requêtes séquentiellement, pas en parallèle
• Ajoutez des en-têtes réalistes : User-Agent, Referer, Accept-Language

Erreur 403 Accès interdit

Le serveur a bloqué votre IP (ou l'IP du proxy). Cela peut être :

• Un filtre par géolocalisation
• Une liste noire de services proxy
• Un détecteur de bot (JavaScript, CAPTCHA)

Solution : utilisez des proxies mobiles ou des proxies résidentiels avec rotation. Ils sont plus difficiles à bloquer.

Erreur 403 : Vérification User-Agent

Certains services rejettent les requêtes avec un User-Agent suspect :

import requests
import random

user_agents = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36",
    "Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15"
]

headers = {
    "User-Agent": random.choice(user_agents),
    "Accept-Language": "en-US,en;q=0.9",
    "Accept": "text/html,application/xhtml+xml",
    "Referer": "https://google.com"
}

response = requests.get(
    "https://target-site.com",
    headers=headers,
    proxies={"http": proxy, "https": proxy},
    timeout=10
)
print(response.status_code)

Erreurs dans le code client

Gestion incorrecte des exceptions

Erreur courante : le code considère une erreur de connexion comme une requête échouée, mais ne tente pas de se reconnecter :

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

# Méthode correcte avec retries
session = requests.Session()
retry_strategy = Retry(
    total=3,
    backoff_factor=1,
    status_forcelist=[429, 500, 502, 503, 504],
    allowed_methods=["GET", "POST"]
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("http://", adapter)
session.mount("https://", adapter)

try:
    response = session.get(url, proxies=proxies, timeout=10)
except requests.exceptions.RequestException as e:
    print(f"Erreur : {e}")
    # Enregistrez et passez à la requête suivante

Délais d'attente incorrects

Si le délai d'attente est trop court (1-2 secondes), les proxies lents seront rejetés :

• Pour l'extraction normale : 10-30 secondes
• Pour les proxies mobiles : 15-45 secondes
• Pour l'API : 5-10 secondes

Erreurs SSL/TLS

Si vous utilisez `verify=False`, cela peut masquer les vrais problèmes. Il est préférable de mettre à jour les certificats :

import requests
import certifi

# Correct
response = requests.get(
    url,
    proxies=proxies,
    verify=certifi.where(),  # Au lieu de verify=False
    timeout=15
)

Problèmes réseau et délais d'attente

Délai de connexion vs délai de lecture

La différence est importante :

• Délai de connexion : le proxy ne répond pas (problème avec le proxy ou le réseau)
• Délai de lecture : le serveur cible envoie les données lentement (problème du serveur cible)

import requests

# timeout = (connection_timeout, read_timeout)
try:
    response = requests.get(
        url,
        proxies=proxies,
        timeout=(5, 15)  # 5 sec pour la connexion, 15 pour la lecture
    )
except requests.exceptions.ConnectTimeout:
    print("Le proxy ne répond pas")
except requests.exceptions.ReadTimeout:
    print("Le serveur cible est lent")

Problèmes DNS

Si le serveur cible ne se résout pas, ce n'est pas une erreur de proxy :

import socket

# Vérifiez le DNS en dehors du proxy
try:
    ip = socket.gethostbyname("target-site.com")
    print(f"Résolu : {ip}")
except socket.gaierror:
    print("Erreur DNS - site non trouvé")

Liste de contrôle du diagnostic du SR faible

1. Établissez une ligne de base : quel SR était normal auparavant ?
2. Exécutez un test isolé (script ci-dessus) avec 100 requêtes
3. Vérifiez les journaux : quels codes HTTP dominent ? (407, 429, 403, délais d'attente ?)
4. Si 407 : vérifiez le nom d'utilisateur/mot de passe et la liste blanche IP
5. Si 429 : ajoutez un délai entre les requêtes, utilisez la rotation IP
6. Si 403 : vérifiez User-Agent, Referer, ajoutez des en-têtes réalistes
7. Si délais d'attente : augmentez le timeout, vérifiez le RPS, utilisez la logique de retry
8. Vérifiez votre code : gestion correcte des exceptions, délais d'attente corrects
9. Vérifiez le serveur cible : est-il accessible directement (sans proxy) ?
10. Si tout le reste échoue : essayez un autre type de proxy ou un autre fournisseur

Tableau de diagnostic rapide

Résumé

Un taux de succès faible est un symptôme, pas une maladie. Les causes peuvent être nombreuses : d'une faute de frappe dans le code au blocage par le serveur cible. Le diagnostic systématique est la clé de la solution :

1. Vérifiez les métriques et les journaux
2. Isolez le problème (proxy vs serveur cible vs votre code)
3. Déterminez le type d'erreur (407, 429, 403, délai d'attente)
4. Appliquez la solution appropriée

Pour les tâches nécessitant une fiabilité et un SR élevé, les proxies résidentiels avec rotation IP sont recommandés. Ils sont plus difficiles à détecter et plus stables. Essayez un test gratuit sur proxycove.com et testez sur votre tâche.