Cómo detectar proxies en Python (paso a paso)

Esta es una guía práctica para detectar proxies desde un backend de Python. Vamos a envolver la API de detección de proxies en una función reutilizable, añadir caché y filtrar una ruta de Flask según el resultado. El mismo enfoque funciona en Django, FastAPI o un script sencillo.

Requisitos previos

Necesitará una clave de API (el nivel gratuito basta para hacer pruebas) y la librería requests:

pip install requests

Guarde su clave en una variable de entorno, nunca en el código fuente.

Paso 1: una función de detección reutilizable

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" significa que un fallo en la detección nunca deja fuera a sus usuarios.

Paso 2: obtener la IP real del cliente

Detrás de un proxy o balanceador de carga, lea la cabecera forwarded que establece su infraestructura:

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

Confíe en X-Forwarded-For solo si un proxy que usted controla establece esa cabecera.

Paso 3: filtrar una ruta de 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)

Paso 4: añadir una caché de corta duración

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

Mantenga el TTL en minutos: el riesgo de una IP cambia, como se explica en qué es la reputación de IP.

Para ir más allá

• Añada detección de VPN para un filtrado específico de VPN.
• Consolide las señales en una única puntuación de fraude de IP.
• Aplique la misma función en el inicio de sesión y en el pago, ajustando los umbrales según la acción.

En resumen

Detectar proxies en Python se reduce a una sola llamada a la API: resolver la IP real del cliente, consultarla y actuar según el tipo y la puntuación. Mantenga el fail open ante errores, cachee brevemente y pida verificación adicional en la franja de riesgo medio en lugar de bloquear directamente.