Een VPN detecteren in Node.js (stap voor stap)

Dit is een praktische handleiding voor het detecteren van VPN-verkeer vanuit een Node.js-backend. We zoeken het IP-adres van de bezoeker op via een VPN-detectie-API, lezen het oordeel en de betrouwbaarheidsscore, en gebruiken die om een aanmelding te reguleren. Hetzelfde patroon werkt voor logins en checkouts.

Voordat je begint

Je hebt een API-sleutel nodig (de gratis laag is genoeg om te testen) en Node 18+, zodat de globale fetch beschikbaar is. Bewaar de sleutel in een omgevingsvariabele, nooit in client-code.

Stap 1: het echte client-IP ophalen

Achter een proxy of load balancer is req.socket.remoteAddress je infrastructuur, niet de gebruiker. Lees de forwarded-header die je vertrouwde proxy instelt:

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;
}

Vertrouw X-Forwarded-For alleen als een proxy die jij beheert deze instelt, anders kan een client de header vervalsen.

Stap 2: de detectie-API aanroepen

Verpak de lookup in een kleine helperfunctie. Deze geeft het oordeel en de score terug, en faalt open (toestaan) bij netwerkfouten, zodat een storing in de detectie je gebruikers nooit buitensluit:

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
  }
}

Stap 3: een aanmelding reguleren op basis van het resultaat

Gebruik nu de score om te beslissen. Onder een drempel toestaan, in het midden extra verificatie vereisen, hoog blokkeren:

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 });
});

Let op dat we in de middelste band extra verificatie vragen in plaats van blokkeren. Zie hoe je VPN-gebruikers op de slimme manier blokkeert voor waarom dat belangrijk is.

Stap 4: cachen om lookups te besparen

Hetzelfde IP-adres komt vaak herhaaldelijk terug. Een kortdurende cache vermindert API-aanroepen zonder verouderde gegevens te riskeren:

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;
}

Houd de TTL kort (minuten, geen dagen), want het IP-risico verandert. Zie wat is IP-reputatie.

Verder gaan

• Voeg proxydetectie toe aan dezelfde flow om niet alleen VPN's, maar ook proxy's en Tor te vangen.
• Bundel de signalen in één IP-fraudescore en reguleer op basis van dat ene getal.
• Pas hetzelfde patroon toe op login en checkout, met per actie aangepaste drempels.

Kortom

VPN-detectie in Node.js is één enkele server-side API-aanroep: het echte client-IP bepalen, opzoeken en handelen op basis van het oordeel en de score. Faal open bij fouten, cache kort, en vraag extra verificatie in de middelste risicoband in plaats van meteen te blokkeren.