Cómo detectar tráfico VPN en Node.js y Python
Sumá middleware en Express y FastAPI que lea flags de redes VPN conocidas, exits de Tor, relays de privacidad y hosting, y después loguee, limite la tasa o pida más verificación, sin bloquear de una a usuarios reales.
Free: 1.000 req/mes · HTTPS · uso personal y no comercial
Qué cubre esta guía (y qué no)
Esta es una receta para tráfico de requests en vivo en Express y en Python (FastAPI / Starlette): un middleware que consulta la IP del cliente, lee los flags de riesgo y decide si loguear, limitar la tasa o pedir una verificación extra. No es una política de scoring para registros: para eso usá Detectar registros sospechosos por IP en Python.
Un flag de “detección de VPN” no es un veredicto de que la persona está ocultando algo, y no es detección de proxies. traits.is_vpn significa que la IP pertenece a una red VPN conocida, incluidos los proveedores comerciales grandes. Redes enteras de hosting con mucha VPN quedan marcadas, así que otros servers de esas redes también. Un rango nuevo de VPN puede seguir en false hasta que los datos lo incorporen.
Los flags de riesgo (is_vpn, is_tor, is_relay, is_hosting) están en los planes pagos. Las keys Free solo devuelven geolocalización + ASN; esos flags se omiten. Free es 1.000 requests por mes calendario UTC, 1 request/segundo, para uso personal y no comercial. Los planes pagos empiezan en USD 9/mes (Starter: 100 mil requests, 10 req/s; Growth: USD 29 / 500 mil / 25 req/s; Scale: USD 79 / 2M / 50 req/s). Sin cargos por excedentes. El uso comercial requiere un plan pago.
Primero obtené la IP real del cliente
Detrás de Nginx, un balanceador o un CDN, la dirección del socket es la del proxy, no la del visitante. En Express, configurá trust proxy según tu topología y usá req.ip: nunca parsees X-Forwarded-For a mano. El setup completo está en Obtener la IP y el país del visitante en Express. En FastAPI / Uvicorn, arrancá con --proxy-headers --forwarded-allow-ips para que request.client.host sea el visitante. Sacá el prefijo ::ffff: de las IPv4 mapeadas en IPv6 antes de consultar la IP.
Los flags que vas a usar
Una llamada a GET /v0/ip/{ip} con Authorization: Bearer devuelve location, network y traits. Con una key paga, estos son los traits que importan para el tráfico:
is_vpn— redes VPN conocidas, incluidos los proveedores comerciales grandes.is_tor— la IP es un exit node actual de Tor (solo exits, no guards, relays del medio ni bridges).is_relay— egress de un relay de privacidad. Está separado deis_vpn, para que no trates a esos usuarios como si usaran VPN. Ver Detectar IPs de iCloud Private Relay.is_hosting— detección de hosting/datacenter: redes cloud, hosting y CDN desde las que un usuario real rara vez navega.
Detrás de una VPN, un exit de Tor o un relay de privacidad, location es la del egress, no la del usuario. Usá los flags como señales, no como un bloqueo duro: pedí una verificación extra, ajustá un rate limit o mandá un challenge, y seguí si la consulta falla.
Middleware en Express
Dejá la key en NDL_API_KEY en el servidor. Este helper cachea por IP, corta a los 800 ms y falla abierto. Enganchalo después de configurar trust proxy:
// vpn-mw.js (Node 18+, global fetch)
const API = "https://api.networkdatalabs.com/v0/ip/";
const KEY = process.env.NDL_API_KEY;
const cache = new Map(); // swap for Redis/LRU in production
const TTL_MS = 6 * 60 * 60 * 1000;
function normalize(ip) {
return ip && ip.startsWith("::ffff:") ? ip.slice(7) : ip;
}
async function lookup(ip) {
const hit = cache.get(ip);
if (hit && hit.exp > Date.now()) return hit.data;
const res = await fetch(API + encodeURIComponent(ip), {
headers: { Authorization: `Bearer ${KEY}` },
signal: AbortSignal.timeout(800),
});
if (!res.ok) throw new Error(`lookup ${res.status}`);
const data = await res.json();
cache.set(ip, { data, exp: Date.now() + TTL_MS });
return data;
}
function vpnTraffic() {
return async (req, res, next) => {
try {
req.ipIntel = await lookup(normalize(req.ip));
} catch {
req.ipIntel = null; // fail open: never block the request
}
next();
};
}
module.exports = { vpnTraffic };
// app.js
const express = require("express");
const { vpnTraffic } = require("./vpn-mw");
const app = express();
app.set("trust proxy", 1); // one reverse proxy; see the Express guide
app.use(vpnTraffic());
app.get("/account", (req, res) => {
const t = req.ipIntel?.traits ?? {};
// Step up on known VPN networks, Tor exits or hosting IPs.
// Privacy relay (is_relay) is usually a normal user — log it, don't block.
if (t.is_tor || t.is_vpn || t.is_hosting) {
res.set("X-Step-Up", "verify");
}
res.json({ ok: true });
});
Middleware en Python (FastAPI / Starlette)
La misma política, como middleware ASGI. Decile a Uvicorn en qué proxy confiar y leé request.state.ip_intel en la ruta. Esto es para tráfico de requests, no para la tabla de permitir / verificar / revisar de la guía de registros en Python.
# vpn_mw.py
import os, time
from urllib.parse import quote
import httpx
from starlette.middleware.base import BaseHTTPMiddleware
API = "https://api.networkdatalabs.com/v0/ip/"
HEADERS = {"Authorization": f"Bearer {os.environ['NDL_API_KEY']}"}
_client = httpx.AsyncClient(timeout=httpx.Timeout(0.8), headers=HEADERS)
_cache: dict[str, tuple[float, dict]] = {}
TTL = 6 * 3600
def normalize(ip: str) -> str:
return ip[7:] if ip and ip.startswith("::ffff:") else ip
async def lookup(ip: str) -> dict | None:
hit = _cache.get(ip)
if hit and hit[0] > time.time():
return hit[1]
try:
r = await _client.get(API + quote(ip, safe=""))
r.raise_for_status()
except httpx.HTTPError:
return None # fail open
data = r.json()
_cache[ip] = (time.time() + TTL, data)
return data
class VpnTrafficMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request, call_next):
ip = request.client.host if request.client else ""
request.state.ip_intel = await lookup(normalize(ip))
return await call_next(request)
# app.py — FastAPI behind one trusted proxy
# uvicorn app:app --proxy-headers --forwarded-allow-ips="10.0.0.5"
from fastapi import FastAPI, Request
from vpn_mw import VpnTrafficMiddleware
app = FastAPI()
app.add_middleware(VpnTrafficMiddleware)
@app.get("/account")
async def account(request: Request):
data = request.state.ip_intel
t = (data or {}).get("traits") or {}
step_up = bool(t.get("is_tor") or t.get("is_vpn") or t.get("is_hosting"))
return {"ok": True, "step_up": step_up}
Cómo tratar cada flag
| Señal | Qué significa | Acción sugerida |
|---|---|---|
is_tor | Exit node actual de Tor | Pedí verificación o un challenge; no bloqueés de una salvo que debas |
is_vpn | Redes VPN conocidas, incluidos los proveedores comerciales grandes | Loguealo; pedí más verificación en rutas sensibles (cuenta, pago) |
is_hosting | IP de hosting/datacenter: suele ser scripts y bots | Rate limit más ajustado o un challenge |
is_relay | Relay de privacidad: en general un usuario normal que cuida su privacidad | Permitilo; no trates la ubicación como precisa |
Ejemplo: 8.8.8.8 es hosting, no una VPN
Un resolver DNS público de EE. UU. es un fixture útil. Debería volver como US con is_hosting e is_anycast en true, y is_vpn / is_tor / is_relay en false. Si tu middleware tratara esta IP como una VPN, la regla es demasiado amplia.
$ curl -s https://api.networkdatalabs.com/v0/ip/8.8.8.8 \
-H "Authorization: Bearer YOUR_API_KEY" \
| jq '{country_code: .location.country_code, traits}'
{
"country_code": "US",
"traits": {
"is_anycast": true,
"is_hosting": true,
"is_mobile": false,
"is_satellite": false,
"is_bogon": false,
"is_vpn": false,
"is_tor": false,
"is_relay": false
}
}
Caché, timeouts y cuota
- Cacheá por IP durante unas horas. La mayor parte del tráfico son visitantes repetidos, así que la caché absorbe la mayoría de las consultas.
- Salteá las rutas que no lo necesitan — assets estáticos, health checks — para no gastar cuota ahí.
- Fail-open ante timeouts y errores; registrá que la consulta no estuvo disponible.
- ¿Backfill de logs? Usá
POST /v0/bulk(planes pagos) con hasta 100 IPs por request. Cada IP cuenta para la cuota mensual; una IP inválida aparece enerrorssin fallar el lote.
Preguntas frecuentes
¿Necesito un plan pago para esto?
Sí, para los flags. Las keys Free omiten is_vpn, is_tor, is_relay e is_hosting y solo devuelven geolocalización + ASN, a 1.000 requests por mes calendario UTC y 1 request/segundo, para uso personal y no comercial. El uso comercial requiere un plan pago. Ver la API de detección de VPN y precios.
¿Puedo bloquear de una todas las redes VPN conocidas?
Podés, pero suele salir caro. Hay mucha gente real que entra desde una red VPN conocida o un relay de privacidad. Tratá los flags como señales, sumá fricción en las rutas sensibles y dejá pasar is_relay salvo que tengas un motivo para no hacerlo.
¿Qué hago con IPs de documentación como 203.0.113.10?
Esas direcciones TEST-NET están reservadas. La API las devuelve con traits.is_bogon en true y sin una ubicación útil. Sirven para probar el fail-open; usá una IP pública de EE. UU. como 8.8.8.8 cuando quieras un fixture real de geolocalización + traits.
¿Por qué el país “está mal” en una VPN?
Estás viendo el egress. La IP pertenece a la red VPN conocida, al exit de Tor o al relay de privacidad, así que location.country_code es el país de esa salida, no el del usuario.
Relacionado
- API de detección de VPN: flags de redes VPN conocidas, exit de Tor, relay de privacidad y hosting
- Detectar registros sospechosos por IP en Python
- Obtener la IP y el país del visitante en Express
- Detectar iCloud Private Relay sin bloquear a usuarios de Apple
- Cloudflare Workers: geolocalización de IP y hosting/Tor más allá de request.cf
- API Docs