So erkennen Sie VPN-Benutzer in Ihrer App mit einem API-Aufruf

Integration 1: Express-Middleware

Diese Middleware ruft die VPN-Erkennungs-API auf und hängt das Ergebnis an an req.vpnRisk. Jeder nachgelagerte Routenhandler kann dies überprüfen req.vpnRisk.isVpn Entscheidungen zu treffen ohne den API-Aufruf zu wiederholen.

import type { Request, Response, NextFunction } from 'express';

const VPN_DETECT_URL = 'https://api.botoi.com/v1/vpn-detect';
const BOTOI_API_KEY = process.env.BOTOI_API_KEY;

interface VpnRisk {
  isVpn: boolean;
  isProxy: boolean;
  isTor: boolean;
  isDatacenter: boolean;
  riskScore: number;
}

declare global {
  namespace Express {
    interface Request {
      vpnRisk?: VpnRisk;
    }
  }
}

export async function vpnDetectMiddleware(
  req: Request,
  _res: Response,
  next: NextFunction
) {
  const ip = req.headers['x-forwarded-for']?.toString().split(',')[0]?.trim()
    || req.socket.remoteAddress
    || 'unknown';

  try {
    const res = await fetch(VPN_DETECT_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': \`Bearer \${BOTOI_API_KEY}\`,
      },
      body: JSON.stringify({ ip }),
      signal: AbortSignal.timeout(3000),
    });

    const { data } = await res.json();

    req.vpnRisk = {
      isVpn: data.is_vpn,
      isProxy: data.is_proxy,
      isTor: data.is_tor,
      isDatacenter: data.is_datacenter,
      riskScore: data.risk_score,
    };
  } catch {
    // Fail open: if detection fails, treat as clean
    req.vpnRisk = {
      isVpn: false,
      isProxy: false,
      isTor: false,
      isDatacenter: false,
      riskScore: 0,
    };
  }

  next();
}

// Usage in your route:
// app.use(vpnDetectMiddleware);
//
// app.post('/api/signup', (req, res) => {
//   if (req.vpnRisk?.isVpn) {
//     // require email verification or flag for review
//   }
// });

Die Middleware schlägt beim Öffnen fehl. Wenn die API nicht erreichbar ist oder nach 3 Sekunden eine Zeitüberschreitung auftritt, wird sie festgelegt alle Flags zu false und lässt die Anfrage weiterlaufen. Ihre Benutzer sehen nie einen Fehler verursacht durch einen Ausfall Dritter.

Integration 2: Next.js Checkout-Schutz

Bezahlbetrug folgt einem Muster: neues Konto, Prepaid-Karte, VPN-Verbindung. Dieses Next.js Der Route-Handler des App-Routers prüft alle drei Signale und leitet verdächtige Befehle an den manuellen Modus weiter überprüfen, anstatt sie automatisch zu genehmigen.

import { NextRequest, NextResponse } from 'next/server';

const VPN_DETECT_URL = 'https://api.botoi.com/v1/vpn-detect';
const BOTOI_API_KEY = process.env.BOTOI_API_KEY!;

interface CheckoutBody {
  cardType: 'credit' | 'debit' | 'prepaid';
  accountCreatedAt: string;
  amount: number;
  currency: string;
}

export async function POST(req: NextRequest) {
  const body: CheckoutBody = await req.json();

  const ip = req.headers.get('x-forwarded-for')?.split(',')[0]?.trim()
    || '127.0.0.1';

  // Check VPN status
  const vpnRes = await fetch(VPN_DETECT_URL, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': \`Bearer \${BOTOI_API_KEY}\`,
    },
    body: JSON.stringify({ ip }),
    signal: AbortSignal.timeout(3000),
  });

  const { data: vpnData } = await vpnRes.json();

  const accountAge = Date.now() - new Date(body.accountCreatedAt).getTime();
  const isNewAccount = accountAge < 24 * 60 * 60 * 1000; // less than 24 hours
  const isPrepaid = body.cardType === 'prepaid';
  const isVpn = vpnData.is_vpn || vpnData.is_tor || vpnData.is_proxy;

  // VPN + new account + prepaid card = manual review
  if (isVpn && isNewAccount && isPrepaid) {
    return NextResponse.json({
      status: 'review',
      orderId: crypto.randomUUID(),
      message: 'Order placed. We will confirm within 30 minutes.',
    }, { status: 202 });
  }

  // VPN + new account (no prepaid) = proceed with logging
  if (isVpn && isNewAccount) {
    console.log(JSON.stringify({
      event: 'checkout_vpn_new_account',
      ip,
      riskScore: vpnData.risk_score,
      amount: body.amount,
    }));
  }

  // Process the order normally
  return NextResponse.json({
    status: 'approved',
    orderId: crypto.randomUUID(),
  });
}

Der Hundeführer lehnt die Bestellung nicht ab. Es wird eine 202 mit der Meldung „Wir bestätigen dies innerhalb von 30 Minuten“ zurückgegeben. Nachricht. Dies verschafft Ihrem Team Zeit für die Überprüfung, ohne einem schlechten Akteur den Hinweis zu geben, dass es sich verhalten hat markiert. Berechtigte VPN-Kunden erhalten ihre Bestellung immer noch nach einer kurzen Verzögerung bearbeitet.

Integration 3: Begrenzung der Anmelderate

Credential-Stuffing-Angriffe erfolgen häufig über VPN- oder Proxy-IPs, um IP-basierte Blockierungen zu vermeiden. Wenden Sie für diese Verbindungen strengere Ratenbegrenzungen an: 3 Anmeldeversuche pro 15 Minuten für VPN-Benutzer gegenüber 10 für normale Benutzer.

import type { Request, Response, NextFunction } from 'express';

const VPN_DETECT_URL = 'https://api.botoi.com/v1/vpn-detect';
const BOTOI_API_KEY = process.env.BOTOI_API_KEY;

// VPN users: 3 attempts per 15 minutes
// Regular users: 10 attempts per 15 minutes
const VPN_LOGIN_LIMIT = 3;
const STANDARD_LOGIN_LIMIT = 10;
const WINDOW_MS = 15 * 60 * 1000;

const loginAttempts = new Map<string, { count: number; resetAt: number }>();

export async function loginRateLimit(
  req: Request,
  res: Response,
  next: NextFunction
) {
  const ip = req.headers['x-forwarded-for']?.toString().split(',')[0]?.trim()
    || req.socket.remoteAddress
    || 'unknown';

  // Check VPN status
  let isVpn = false;
  try {
    const vpnRes = await fetch(VPN_DETECT_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': \`Bearer \${BOTOI_API_KEY}\`,
      },
      body: JSON.stringify({ ip }),
      signal: AbortSignal.timeout(2000),
    });

    const { data } = await vpnRes.json();
    isVpn = data.is_vpn || data.is_tor || data.is_proxy;
  } catch {
    // Fail open: use standard limits
  }

  const limit = isVpn ? VPN_LOGIN_LIMIT : STANDARD_LOGIN_LIMIT;
  const now = Date.now();
  const entry = loginAttempts.get(ip);

  if (!entry || entry.resetAt < now) {
    loginAttempts.set(ip, { count: 1, resetAt: now + WINDOW_MS });
    return next();
  }

  entry.count++;

  if (entry.count > limit) {
    const retryAfter = Math.ceil((entry.resetAt - now) / 1000);
    return res.status(429).json({
      error: 'Too many login attempts. Try again later.',
      retryAfter,
    });
  }

  next();
}

// Mount on your login route:
// app.post('/api/auth/login', loginRateLimit, loginHandler);

Das Verhältnis von 3:10 verlangsamt automatisierte Angriffe von VPN-IPs, ohne die meisten echten Benutzer zu beeinträchtigen. Ein legitimer Benutzer eines Unternehmens-VPN, der sein Passwort dreimal falsch eintippt, erhält trotzdem eine Klare Fehlermeldung und ein Wiederholungsfenster, kein dauerhafter Bann.

Erstellen eines zusammengesetzten Risikoscores

Die VPN-Erkennung allein ist ein schwaches Betrugssignal. Viele legitime Benutzer betreiben VPNs. Das Signal kommt Stärker, wenn Sie es mit anderen Prüfungen kombinieren. Rufen Sie drei Botoi-Endpunkte parallel auf:

• /v1/vpn-detect für Verbindungstyp (VPN, Proxy, Tor, Rechenzentrum)
• /v1/disposable-email/check für E-Mail-Qualität (wegwerfbar oder dauerhaft)
• /v1/ip/lookup für geografische Nichtübereinstimmung (IP-Land vs. Rechnungsland)

Diese Funktion ruft alle drei auf und erzeugt einen Risiko-Score von 0–100:

interface RiskResult {
  score: number;
  action: 'allow' | 'review' | 'block';
  signals: {
    vpn: boolean;
    tor: boolean;
    proxy: boolean;
    vpnRiskScore: number;
    disposableEmail: boolean;
    geoMismatch: boolean;
    ipCountry: string;
    billingCountry: string;
  };
}

async function calculateRisk(
  ip: string,
  email: string,
  billingCountry: string
): Promise<RiskResult> {
  const BOTOI_KEY = process.env.BOTOI_API_KEY!;
  const headers = {
    'Content-Type': 'application/json',
    'Authorization': \`Bearer \${BOTOI_KEY}\`,
  };

  // Run all three checks in parallel
  const [vpnRes, emailRes, geoRes] = await Promise.all([
    fetch('https://api.botoi.com/v1/vpn-detect', {
      method: 'POST',
      headers,
      body: JSON.stringify({ ip }),
    }),
    fetch('https://api.botoi.com/v1/disposable-email/check', {
      method: 'POST',
      headers,
      body: JSON.stringify({ email }),
    }),
    fetch('https://api.botoi.com/v1/ip/lookup', {
      method: 'POST',
      headers,
      body: JSON.stringify({ ip }),
    }),
  ]);

  const vpnData = (await vpnRes.json()).data;
  const emailData = (await emailRes.json()).data;
  const geoData = (await geoRes.json()).data;

  const ipCountry = geoData.country_code || '';
  const geoMismatch = ipCountry !== '' && billingCountry !== ''
    && ipCountry.toUpperCase() !== billingCountry.toUpperCase();

  // Weight each signal
  let score = 0;

  // VPN/proxy/Tor: up to 30 points
  if (vpnData.is_vpn || vpnData.is_tor || vpnData.is_proxy) {
    score += Math.round(vpnData.risk_score * 0.3);
  }

  // Disposable email: 25 points
  if (emailData.is_disposable) {
    score += 25;
  }

  // Geo mismatch (IP country != billing country): 20 points
  if (geoMismatch) {
    score += 20;
  }

  // VPN + disposable email combo: extra 15 points
  if ((vpnData.is_vpn || vpnData.is_tor) && emailData.is_disposable) {
    score += 15;
  }

  score = Math.min(score, 100);

  return {
    score,
    action: score > 70 ? 'block' : score > 30 ? 'review' : 'allow',
    signals: {
      vpn: vpnData.is_vpn,
      tor: vpnData.is_tor,
      proxy: vpnData.is_proxy,
      vpnRiskScore: vpnData.risk_score,
      disposableEmail: emailData.is_disposable,
      geoMismatch,
      ipCountry,
      billingCountry,
    },
  };
}

// Example usage:
// const risk = await calculateRisk('185.220.101.1', 'user@tempmail.com', 'US');
// if (risk.action === 'review') { queueForManualReview(orderId); }
// if (risk.action === 'block') { rejectTransaction(orderId); }

Alle drei API-Aufrufe laufen parallel mit Promise.all, also ist die Gesamtlatenz gleich der langsamste Anruf (normalerweise unter 100 ms). Die Bewertungsgewichte sind ein Ausgangspunkt. Stimmen Sie sie ab basierend auf Ihren Betrugsdaten. Wenn Wegwerf-E-Mails Ihre größte Quelle für Rückbuchungen sind, erhöhen Sie die Zahl dieses Gewicht. Wenn geografische Nichtübereinstimmungen selten sind und für Ihre Benutzerbasis normalerweise harmlos sind, verringern Sie sie.

Wann VPN-Benutzer NICHT blockiert werden sollten

Das harte Blockieren des VPN-Verkehrs ist für die meisten Anwendungen ein Fehler. Hier sind die häufigsten Gründe Menschen verbinden sich über ein VPN:

• Unternehmenspolitik. Companies route employee traffic through a VPN by default. Wenn Sie diese Verbindungen blockieren, können Ihre B2B-Kunden Ihr Produkt während der Arbeitszeit nicht nutzen.
• Privatsphäre. Datenschutzbewusste Benutzer nutzen grundsätzlich VPNs für jede Verbindung Sicherheitsmaßnahme. Sie zahlen Kunden, keine Betrüger.
• Eingeschränkter Internetzugang. Benutzer in bestimmten Ländern verlassen sich auf VPNs, um zu erreichen Ihr Produkt überhaupt. Durch das Blockieren von VPNs werden diese vollständig gesperrt.
• Öffentliches WLAN. Jeder in einem Café oder Flughafennetzwerk sollte a verwenden VPN. Sie für gute Sicherheitshygiene zu bestrafen, schafft den falschen Anreiz.
• Journalisten und Forscher. Personen in diesen Rollen nutzen Tor und VPNs für Quellenschutz und Betriebssicherheit. Sie zu blockieren kann weitreichende Folgen haben.

Der richtige Ansatz: Markieren und punkten, nicht hart blocken. Verwenden Sie die VPN-Erkennung als eine Eingabe für a Risikofunktion, die mehrere Signale berücksichtigt. Leiten Sie Transaktionen mit hohem Risiko an eine Überprüfungswarteschlange weiter. Überlassen Sie es den Menschen, in unklaren Fällen die letzte Entscheidung zu treffen.

Wichtige Punkte

• POST /v1/vpn-detect kehrt zurück is_vpn, is_proxy, is_tor, is_datacenter, Und risk_score für jede IP.
• Zum Testen ist kein API-Schlüssel erforderlich (5 Anfragen pro Minute). Kostenlose Schlüssel schalten höhere Limits frei für die Produktion.
• Hängen Sie die VPN-Prüfung an die Express-Middleware an, damit jede Route Zugriff auf die Risikodaten hat ohne den Anruf zu wiederholen.
• Kombinieren Sie die VPN-Erkennung mit einmaligen E-Mail-Überprüfungen und IP-Geolokalisierung für eine Verbindung Risikobewertung, die stark genug ist, um darauf zu reagieren.
• Markieren Sie VPN-Verbindungen zur Überprüfung. Blockiere sie nicht. Legitime Benutzer betreiben VPNs für Datenschutz, Unternehmensrichtlinien und eingeschränkter Internetzugang.