So erkennen Sie ein VPN in Node.js (Schritt für Schritt)

Dies ist eine praktische Anleitung zur Erkennung von VPN-Traffic aus einem Node.js-Backend. Wir schlagen die IP-Adresse des Besuchers in einer VPN-Erkennungs-API nach, lesen das Ergebnis und den Konfidenzwert aus und nutzen sie, um eine Registrierung zu steuern. Das gleiche Muster funktioniert auch für Logins und Checkouts.

Bevor Sie beginnen

Sie benötigen einen API-Schlüssel (die kostenlose Stufe reicht zum Testen) und Node 18+, damit das globale fetch verfügbar ist. Bewahren Sie den Schlüssel in einer Umgebungsvariable auf, niemals im Client-Code.

Schritt 1: Die echte Client-IP ermitteln

Hinter einem Proxy oder Load Balancer zeigt req.socket.remoteAddress auf Ihre Infrastruktur, nicht auf den Nutzer. Lesen Sie den Forwarded-Header aus, den Ihr vertrauenswürdiger Proxy setzt:

function getClientIp(req) {
  const xff = req.headers['x-forwarded-for'];
  if (xff) return xff.split(',')[0].trim(); // left-most = original client
  return req.socket.remoteAddress;
}

Vertrauen Sie X-Forwarded-For nur, wenn ein von Ihnen kontrollierter Proxy ihn setzt, andernfalls könnte ein Client ihn fälschen.

Schritt 2: Die Erkennungs-API aufrufen

Verpacken Sie die Abfrage in einem kleinen Helfer. Er liefert das Ergebnis und den Score zurück und fällt bei Netzwerkfehlern offen aus (erlaubt den Zugriff), damit ein Ausfall der Erkennung niemals Ihre Nutzer aussperrt:

const API_BASE = 'https://ipscanner.io';

async function checkVpn(ip) {
  try {
    const res = await fetch(`${API_BASE}/v1/vpn/${ip}`, {
      headers: { Authorization: `Bearer ${process.env.IPSCANNER_API_KEY}` }
    });
    if (!res.ok) throw new Error(`lookup failed: ${res.status}`);
    const data = await res.json();
    return { isVpn: Boolean(data.vpn), score: data.score ?? 0 };
  } catch (err) {
    console.error('vpn check error', err);
    return { isVpn: false, score: 0 }; // fail open
  }
}

Schritt 3: Eine Registrierung anhand des Ergebnisses steuern

Nutzen Sie nun den Score zur Entscheidung. Unterhalb eines Schwellenwerts erlauben, im mittleren Bereich zusätzliche Verifizierung verlangen, bei hohen Werten blockieren:

app.post('/signup', async (req, res) => {
  const ip = getClientIp(req);
  const { isVpn, score } = await checkVpn(ip);

  if (score >= 70) {
    return res.status(403).json({ error: 'Signups from this network need verification.' });
  }
  if (isVpn || score >= 30) {
    req.session.requireEmailVerification = true; // add friction, don't block
  }

  // ...create the account...
  res.json({ ok: true });
});

Beachten Sie, dass wir im mittleren Bereich eine zusätzliche Prüfung anfordern, statt zu blockieren. Warum das wichtig ist, erfahren Sie unter wie man VPN-Nutzer richtig blockiert.

Schritt 4: Caching, um Abfragen zu sparen

Dieselbe IP trifft oft wiederholt bei Ihnen ein. Ein kurzlebiger Cache reduziert API-Aufrufe, ohne veraltete Daten zu riskieren:

const cache = new Map(); // ip -> { value, expires }

async function checkVpnCached(ip, ttlMs = 10 * 60 * 1000) {
  const hit = cache.get(ip);
  if (hit && hit.expires > Date.now()) return hit.value;
  const value = await checkVpn(ip);
  cache.set(ip, { value, expires: Date.now() + ttlMs });
  return value;
}

Halten Sie die TTL kurz (Minuten, nicht Tage), da sich das IP-Risiko ändert. Mehr dazu unter was ist IP-Reputation.

Weiterführende Schritte

• Ergänzen Sie den gleichen Ablauf um Proxy-Erkennung, um nicht nur VPNs, sondern auch Proxys und Tor zu erfassen.
• Fassen Sie die Signale in einem einzigen IP-Betrugsscore zusammen und steuern Sie anhand dieser einen Zahl.
• Wenden Sie das gleiche Muster auf Login und Checkout an und passen Sie die Schwellenwerte je Aktion an.

Fazit

VPN-Erkennung in Node.js ist ein einziger serverseitiger API-Aufruf: die echte Client-IP ermitteln, abfragen und anhand von Ergebnis und Score handeln. Bei Fehlern offen ausfallen, kurz cachen und im mittleren Risikobereich eine Prüfung anfordern statt sofort zu blockieren.