Détecter les proxys en Python (guide étape par étape)

Ce guide pratique explique comment détecter les proxys depuis un backend Python. Nous allons encapsuler l'API de détection de proxy dans une fonction réutilisable, ajouter un cache, puis filtrer une route Flask selon le résultat. La même approche fonctionne avec Django, FastAPI ou un simple script.

Prérequis

Il vous faut une clé API (le niveau gratuit suffit pour tester) et la bibliothèque requests :

pip install requests

Conservez votre clé dans une variable d'environnement, jamais dans le code source.

Étape 1 : une fonction de détection réutilisable

import os
import requests

API_BASE = "https://ipscanner.io"
API_KEY = os.environ["IPSCANNER_API_KEY"]

def check_proxy(ip: str) -> dict:
    """Return {'is_proxy': bool, 'type': str|None, 'score': int}. Fails open."""
    try:
        resp = requests.get(
            f"{API_BASE}/v1/proxy/{ip}",
            headers={"Authorization": f"Bearer {API_KEY}"},
            timeout=3,
        )
        resp.raise_for_status()
        data = resp.json()
        return {
            "is_proxy": bool(data.get("proxy")),
            "type": data.get("type"),
            "score": data.get("score", 0),
        }
    except requests.RequestException:
        return {"is_proxy": False, "type": None, "score": 0}  # fail open

Le "fail open" garantit qu'une panne de la détection ne bloque jamais vos utilisateurs.

Étape 2 : récupérer l'IP réelle du client

Derrière un proxy ou un load balancer, lisez l'en-tête forwarded défini par votre infrastructure :

def client_ip(request) -> str:
    xff = request.headers.get("X-Forwarded-For", "")
    if xff:
        return xff.split(",")[0].strip()  # left-most = original client
    return request.remote_addr

Ne faites confiance à X-Forwarded-For que si un proxy que vous contrôlez définit cet en-tête.

Étape 3 : filtrer une route Flask

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.post("/signup")
def signup():
    ip = client_ip(request)
    result = check_proxy(ip)

    if result["score"] >= 70:
        return jsonify(error="This network requires verification."), 403
    if result["is_proxy"] or result["score"] >= 30:
        # add friction instead of blocking: require email/phone verification
        request.environ["require_verification"] = True

    # ...create the account...
    return jsonify(ok=True)

Étape 4 : ajouter un cache de courte durée

import time

_cache: dict[str, tuple[dict, float]] = {}

def check_proxy_cached(ip: str, ttl: int = 600) -> dict:
    hit = _cache.get(ip)
    if hit and hit[1] > time.time():
        return hit[0]
    value = check_proxy(ip)
    _cache[ip] = (value, time.time() + ttl)
    return value

Gardez un TTL de l'ordre de la minute : le risque associé à une IP évolue, comme expliqué dans qu'est-ce que la réputation IP.

Pour aller plus loin

• Ajoutez la détection VPN pour un filtrage spécifique aux VPN.
• Regroupez les signaux dans un score de fraude IP unique.
• Appliquez la même fonction à la connexion et au paiement, en ajustant les seuils selon l'action.

En résumé

Détecter les proxys en Python tient en un seul appel API : résoudre l'IP réelle du client, la vérifier, puis agir selon le type et le score. Restez en fail open sur les erreurs, mettez en cache brièvement, et demandez une vérification supplémentaire dans la zone de risque moyenne plutôt que de bloquer directement.