Proxys mit Python erkennen (Schritt für Schritt)

Dies ist eine praxisnahe Anleitung zur Erkennung von Proxys aus einem Python-Backend. Wir kapseln die Proxy-Erkennungs-API in einer wiederverwendbaren Funktion, fügen Caching hinzu und filtern eine Flask-Route anhand des Ergebnisses. Derselbe Ansatz funktioniert in Django, FastAPI oder einem einfachen Skript.

Voraussetzungen

Sie benötigen einen API-Schlüssel (die kostenlose Stufe reicht zum Testen) und die Bibliothek requests:

pip install requests

Bewahren Sie Ihren Schlüssel in einer Umgebungsvariablen auf, niemals im Quellcode.

Schritt 1: eine wiederverwendbare Erkennungsfunktion

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" bedeutet, dass ein Ausfall der Erkennung Ihre Nutzer niemals aussperrt.

Schritt 2: die echte Client-IP ermitteln

Hinter einem Proxy oder Load Balancer lesen Sie den Forwarded-Header, den Ihre Infrastruktur setzt:

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

Vertrauen Sie X-Forwarded-For nur, wenn ein von Ihnen kontrollierter Proxy diesen Header setzt.

Schritt 3: eine Flask-Route filtern

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)

Schritt 4: einen kurzlebigen Cache hinzufügen

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

Halten Sie die TTL im Minutenbereich, das IP-Risiko ändert sich, wie im Artikel Was ist IP-Reputation beschrieben.

Weiterführende Schritte

• Fügen Sie VPN-Erkennung für VPN-spezifisches Filtern hinzu.
• Fassen Sie Signale in einem IP-Betrugswert zusammen.
• Wenden Sie dieselbe Funktion bei Login und Checkout an und passen Sie die Schwellenwerte je nach Aktion an.

Fazit

Proxys mit Python zu erkennen ist ein einziger API-Aufruf: die echte Client-IP ermitteln, nachschlagen und anhand von Typ und Score entscheiden. Bei Fehlern offen bleiben, kurzzeitig cachen und im mittleren Risikobereich zusätzliche Prüfungen verlangen, statt hart zu blockieren.