Proxy's detecteren met Python (stap voor stap)

Dit is een praktische handleiding voor het detecteren van proxy's vanuit een Python-backend. We verpakken de proxy-detectie-API in een herbruikbare functie, voegen caching toe en filteren een Flask-route op basis van het resultaat. Dezelfde aanpak werkt in Django, FastAPI of een gewoon script.

Vereisten

U hebt een API-sleutel nodig (de gratis laag volstaat om te testen) en de bibliotheek requests:

pip install requests

Bewaar uw sleutel in een omgevingsvariabele, nooit in de broncode.

Stap 1: een herbruikbare detectiefunctie

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

"Fail open" betekent dat een storing in de detectie uw gebruikers nooit buitensluit.

Stap 2: het echte client-IP ophalen

Achter een proxy of load balancer leest u de forwarded-header die uw infrastructuur instelt:

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

Vertrouw X-Forwarded-For alleen als een proxy die u zelf beheert, deze header instelt.

Stap 3: een Flask-route filteren

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)

Stap 4: een kortstondige cache toevoegen

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

Houd de TTL in minuten, het IP-risico verandert, zoals beschreven in wat is IP-reputatie.

Verder gaan

• Voeg VPN-detectie toe voor VPN-specifieke filtering.
• Bundel signalen in één IP-fraudescore.
• Pas dezelfde functie toe bij inloggen en afrekenen, en stem de drempels af per actie.

Kortom

Proxy's detecteren met Python komt neer op één API-aanroep: het echte client-IP bepalen, opzoeken en handelen op basis van het type en de score. Blijf open bij fouten, cache kort en vraag extra verificatie in de middelste risicozone in plaats van hard te blokkeren.