Logistics & Supply Chain Verification

class BrokerVerifier {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://scamverify.ai/api/v1';
  }

  async callApi(endpoint, body) {
    const response = await fetch(`${this.baseUrl}${endpoint}`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(body),
    });
    if (!response.ok) throw new Error(`API error: ${response.status}`);
    return response.json();
  }

  async verifyBroker(broker) {
    const { name, phone, website, mcNumber } = broker;
    const findings = { flags: [], riskFactors: 0 };

    // Step 1: Verify the broker's phone number
    const phoneCheck = await this.callApi('/phone/lookup', {
      phone_number: phone,
    });

    findings.phone = {
      riskScore: phoneCheck.risk_score,
      lineType: phoneCheck.signals.line_type,
      carrier: phoneCheck.signals.carrier,
      ftcComplaints: phoneCheck.signals.ftc_complaints,
    };

    if (phoneCheck.signals.line_type === 'voip' && phoneCheck.risk_score >= 30) {
      findings.flags.push({
        severity: 'high',
        signal: 'disposable_voip',
        detail: `VoIP number from ${phoneCheck.signals.carrier} with risk score ${phoneCheck.risk_score}. Legitimate brokerages use business phone systems.`,
      });
      findings.riskFactors++;
    }

    if (phoneCheck.signals.ftc_complaints > 0) {
      findings.flags.push({
        severity: 'critical',
        signal: 'ftc_complaints',
        detail: `${phoneCheck.signals.ftc_complaints} FTC complaint(s) filed against this number.`,
      });
      findings.riskFactors += 2;
    }

    if (phoneCheck.signals.robocall_detected) {
      findings.flags.push({
        severity: 'critical',
        signal: 'robocall',
        detail: 'Number associated with automated calling campaigns.',
      });
      findings.riskFactors += 2;
    }

    // Step 2: Verify the broker's website
    if (website) {
      const urlCheck = await this.callApi('/url/lookup', { url: website });

      findings.website = {
        riskScore: urlCheck.risk_score,
        verdict: urlCheck.verdict,
      };

      if (urlCheck.risk_score >= 30) {
        findings.flags.push({
          severity: 'high',
          signal: 'suspicious_website',
          detail: `Website flagged: ${urlCheck.explanation}`,
        });
        findings.riskFactors++;
      }
    }

    // Overall assessment
    if (findings.riskFactors >= 3) {
      findings.assessment = 'REJECT';
      findings.recommendation = 'Do not engage. Multiple fraud indicators detected.';
    } else if (findings.riskFactors >= 1) {
      findings.assessment = 'VERIFY';
      findings.recommendation = 'Proceed only after independent verification of MC number, DOT number, and insurance certificate.';
    } else {
      findings.assessment = 'LOW_RISK';
      findings.recommendation = 'No fraud indicators detected. Standard verification procedures apply.';
    }

    return { broker: name, ...findings };
  }

  async batchVerify(brokers) {
    const results = [];

    for (const broker of brokers) {
      try {
        const result = await this.verifyBroker(broker);
        results.push(result);
      } catch (error) {
        results.push({
          broker: broker.name,
          error: error.message,
          assessment: 'ERROR',
        });
      }
    }

    // Summary statistics
    const summary = {
      total: results.length,
      rejected: results.filter(r => r.assessment === 'REJECT').length,
      needsVerification: results.filter(r => r.assessment === 'VERIFY').length,
      lowRisk: results.filter(r => r.assessment === 'LOW_RISK').length,
      errors: results.filter(r => r.assessment === 'ERROR').length,
    };

    return { summary, results };
  }
}

// Usage: Weekly broker list verification
const verifier = new BrokerVerifier(process.env.SCAMVERIFY_API_KEY);

app.post('/api/brokers/batch-verify', async (req, res) => {
  const { brokers } = req.body;

  const verification = await verifier.batchVerify(brokers);

  // Store results for the dispatch team
  await saveBrokerVerificationReport(verification);

  return res.json(verification);
});

import requests
import os
from typing import Optional

class BrokerVerifier:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://scamverify.ai/api/v1"

    def _call_api(self, endpoint: str, body: dict) -> dict:
        response = requests.post(
            f"{self.base_url}{endpoint}",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json",
            },
            json=body,
        )
        response.raise_for_status()
        return response.json()

    def verify_broker(
        self, name: str, phone: str, website: Optional[str] = None
    ) -> dict:
        flags = []
        risk_factors = 0

        phone_check = self._call_api("/phone/lookup", {"phone_number": phone})

        if (
            phone_check["signals"]["line_type"] == "voip"
            and phone_check["risk_score"] >= 30
        ):
            flags.append("Disposable VoIP number detected")
            risk_factors += 1

        if phone_check["signals"]["ftc_complaints"] > 0:
            flags.append(
                f"{phone_check['signals']['ftc_complaints']} FTC complaints"
            )
            risk_factors += 2

        if website:
            url_check = self._call_api("/url/lookup", {"url": website})
            if url_check["risk_score"] >= 30:
                flags.append(f"Suspicious website: {url_check['explanation']}")
                risk_factors += 1

        if risk_factors >= 3:
            assessment = "REJECT"
        elif risk_factors >= 1:
            assessment = "VERIFY"
        else:
            assessment = "LOW_RISK"

        return {
            "broker": name,
            "phone_risk_score": phone_check["risk_score"],
            "line_type": phone_check["signals"]["line_type"],
            "flags": flags,
            "assessment": assessment,
        }

    def batch_verify(self, brokers: list[dict]) -> dict:
        results = []
        for broker in brokers:
            result = self.verify_broker(
                name=broker["name"],
                phone=broker["phone"],
                website=broker.get("website"),
            )
            results.append(result)

        return {
            "total": len(results),
            "rejected": sum(1 for r in results if r["assessment"] == "REJECT"),
            "needs_verification": sum(
                1 for r in results if r["assessment"] == "VERIFY"
            ),
            "low_risk": sum(
                1 for r in results if r["assessment"] == "LOW_RISK"
            ),
            "results": results,
        }