Implementation Guides

import { Prynt } from '@prynt/sdk';

const prynt = new Prynt({
  apiKey: 'pk_live_xxxxxxxxxxxx',
});

// Identify on page load or before a protected action
const { requestId } = await prynt.identify();

// Send to your server for verification
const response = await fetch('/api/check-bot', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ requestId }),
});

import { PryntServer } from '@prynt/node';

const prynt = new PryntServer({
  secretKey: process.env.PRYNT_SECRET_KEY,
});

app.post('/api/check-bot', async (req, res) => {
  const event = await prynt.getEvent(req.body.requestId);

  if (event.signals.bot.detected) {
    console.log('Bot detected:', event.signals.bot.type);
    return res.status(403).json({
      error: 'bot_detected',
      botType: event.signals.bot.type,
    });
  }

  // Not a bot -- proceed
  res.json({ action: 'allow' });
});

from prynt import PryntServer
from flask import Flask, request, jsonify

app = Flask(__name__)
prynt = PryntServer(secret_key=os.environ["PRYNT_SECRET_KEY"])

@app.route("/api/check-bot", methods=["POST"])
def check_bot():
    request_id = request.json["requestId"]
    event = prynt.get_event(request_id)

    if event.signals.bot.detected:
        return jsonify({
            "error": "bot_detected",
            "botType": event.signals.bot.type,
        }), 403

    return jsonify({"action": "allow"})

import { PryntServer } from '@prynt/node';
import { db } from './database';

const prynt = new PryntServer({
  secretKey: process.env.PRYNT_SECRET_KEY,
});

app.post('/api/login', async (req, res) => {
  const { email, password, requestId } = req.body;

  // 1. Validate credentials (your existing auth logic)
  const user = await db.verifyCredentials(email, password);
  if (!user) return res.status(401).json({ error: 'invalid_credentials' });

  // 2. Get Prynt identification
  const event = await prynt.getEvent(requestId);
  const { visitorId, signals, scores } = event;

  // 3. Check if this device is trusted for this user
  const trustedDevices = await db.getTrustedDevices(user.id);
  const isTrusted = trustedDevices.includes(visitorId);

  // 4. Evaluate risk
  if (scores.ato > 0.7 || signals.impossibleTravel?.detected) {
    // High risk -- block and notify account owner
    await notifyUser(user, 'suspicious_login');
    return res.status(403).json({
      error: 'login_blocked',
      reason: 'suspicious_activity',
    });
  }

  if (!isTrusted || signals.vpn?.detected) {
    // Medium risk -- require MFA
    return res.json({
      action: 'require_mfa',
      visitorId: visitorId,
    });
  }

  // 5. Low risk -- allow login, update last seen
  await db.updateLastSeen(user.id, visitorId);
  res.json({ action: 'allow', token: generateToken(user) });
});

from prynt import PryntServer
from flask import Flask, request, jsonify

prynt = PryntServer(secret_key=os.environ["PRYNT_SECRET_KEY"])

@app.route("/api/login", methods=["POST"])
def login():
    data = request.json
    user = verify_credentials(data["email"], data["password"])
    if not user:
        return jsonify({"error": "invalid_credentials"}), 401

    event = prynt.get_event(data["requestId"])
    trusted = get_trusted_devices(user.id)

    # High risk: block
    if event.scores.ato > 0.7:
        return jsonify({"error": "login_blocked"}), 403

    # Unknown device: require MFA
    if event.visitor_id not in trusted:
        return jsonify({"action": "require_mfa"}), 200

    # Trusted device: allow
    return jsonify({"action": "allow", "token": generate_token(user)})

import { PryntServer } from '@prynt/node';

const prynt = new PryntServer({
  secretKey: process.env.PRYNT_SECRET_KEY,
});

async function evaluatePaymentRisk(requestId, amount) {
  const event = await prynt.getEvent(requestId);
  const { scores, signals, visitorId } = event;

  // Composite risk score
  let risk = scores.abuse * 100;

  // Boost risk for suspicious signals
  if (signals.vpn?.detected)     risk += 15;
  if (signals.tor)               risk += 30;
  if (signals.emulator)          risk += 25;
  if (signals.incognito)         risk += 10;
  if (signals.tampered)          risk += 20;

  // Amount-based risk adjustment
  if (amount > 500)             risk += 10;
  if (amount > 2000)            risk += 20;

  // Decision
  if (risk >= 70) return { action: 'block',     risk };
  if (risk >= 40) return { action: 'review',    risk };
  if (risk >= 20) return { action: 'challenge', risk };
  return { action: 'allow', risk };
}

app.post('/api/checkout', async (req, res) => {
  const { requestId, amount, paymentMethodId } = req.body;

  // Step 1: Evaluate risk BEFORE charging
  const riskResult = await evaluatePaymentRisk(requestId, amount);

  if (riskResult.action === 'block') {
    return res.status(403).json({
      error: 'payment_declined',
      message: 'This transaction could not be processed.',
    });
  }

  if (riskResult.action === 'challenge') {
    return res.json({
      action: 'verify_identity',
      message: 'Additional verification required.',
    });
  }

  // Step 2: Process payment (low risk)
  const charge = await stripe.paymentIntents.create({
    amount: amount,
    payment_method: paymentMethodId,
    confirm: true,
    metadata: {
      prynt_visitor_id: riskResult.visitorId,
      prynt_risk_score: riskResult.risk.toString(),
    },
  });

  res.json({ action: 'charged', chargeId: charge.id });
});

// When a chargeback is received, blocklist the device
app.post('/webhooks/chargeback', async (req, res) => {
  const { chargeId } = req.body;

  // Get the visitorId from your payment record
  const payment = await db.getPayment(chargeId);
  const visitorId = payment.metadata.prynt_visitor_id;

  // Add to blocklist via Prynt Lists API
  await prynt.lists.addEntries('lst_fraud_devices', [
    { type: 'visitor_id', value: visitorId },
  ]);

  console.log(`Blocklisted device ${visitorId} for chargeback`);
  res.sendStatus(200);
});

# Add this CNAME record in your DNS provider
Type:   CNAME
Name:   metrics            # becomes metrics.yourdomain.com
Value:  proxy-us.prynt.io
TTL:    300                 # 5 minutes

server {
    listen 443 ssl;
    server_name metrics.yourdomain.com;

    ssl_certificate     /etc/ssl/certs/metrics.crt;
    ssl_certificate_key /etc/ssl/private/metrics.key;

    location / {
        proxy_pass         https://api.prynt.io;
        proxy_set_header   Host api.prynt.io;
        proxy_set_header   X-Forwarded-For $remote_addr;
        proxy_set_header   X-Real-IP $remote_addr;
        proxy_ssl_server_name on;

        # Cache control -- do not cache identification responses
        proxy_cache        off;
        proxy_buffering    off;
    }
}

export default {
  async fetch(request) {
    const url = new URL(request.url);

    // Rewrite to Prynt API
    url.hostname = 'api.prynt.io';

    const proxyRequest = new Request(url, {
      method: request.method,
      headers: request.headers,
      body: request.body,
    });

    // Forward client IP for accurate geolocation
    proxyRequest.headers.set(
      'X-Forwarded-For',
      request.headers.get('CF-Connecting-IP')
    );

    return fetch(proxyRequest);
  },
}

import { Prynt } from '@prynt/sdk';

const prynt = new Prynt({
  apiKey: 'pk_live_xxxxxxxxxxxx',
  endpoint: 'https://metrics.yourdomain.com',  // your proxy
});

// Test identification through the proxy
const result = await prynt.identify();
console.log('Visitor ID:', result.visitorId);
console.log('Proxied:', result.meta.endpoint); // should show your domain

import { Prynt } from '@prynt/sdk';

const prynt = new Prynt({
  apiKey: 'pk_live_xxxxxxxxxxxx',
  sealed: true,  // Enable sealed results
});

const { sealedResult } = await prynt.identify();

// Send the encrypted blob to your server
await fetch('/api/verify', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ sealedResult }),
});

import { PryntServer } from '@prynt/node';

const prynt = new PryntServer({
  secretKey: process.env.PRYNT_SECRET_KEY,
});

app.post('/api/verify', async (req, res) => {
  // Decrypt the sealed result locally -- no API call needed
  const event = await prynt.unsealResult(req.body.sealedResult);

  // Full identification data is now available
  console.log(event.visitorId);     // "pv_8kX2mNqR3jT7p"
  console.log(event.confidence);    // 0.995
  console.log(event.signals.bot);   // { detected: false }
  console.log(event.scores);        // { abuse: 0.03, ato: 0.01, ... }

  // Make decisions as usual
  if (event.signals.bot.detected) {
    return res.status(403).json({ error: 'bot_detected' });
  }

  res.json({ action: 'allow', visitorId: event.visitorId });
});

from prynt import PryntServer

prynt = PryntServer(secret_key=os.environ["PRYNT_SECRET_KEY"])

@app.route("/api/verify", methods=["POST"])
def verify():
    sealed = request.json["sealedResult"]
    event = prynt.unseal_result(sealed)

    # Full data available without API call
    if event.signals.bot.detected:
        return jsonify({"error": "bot_detected"}), 403

    return jsonify({"action": "allow"})

import { PryntServer } from '@prynt/node';

const prynt = new PryntServer({
  secretKey: process.env.PRYNT_SECRET_KEY,
});

// Create a rule and backtest it
const rule = await prynt.rules.create({
  name: 'High-risk ATO block',
  conditions: [
    { field: 'scores.ato', op: 'gt', value: 0.7 },
    { field: 'signals.vpn.detected', op: 'eq', value: true },
  ],
  action: 'block',
  enabled: false,  // Don't enable yet
});

// Run backtest against last 7 days
const backtest = await prynt.rules.backtest(rule.id, {
  days: 7,
});

console.log('Total events analyzed:', backtest.totalEvents);
console.log('Events matched:', backtest.matchedEvents);
console.log('Match rate:', backtest.matchRate);
console.log('Sample matches:', backtest.samples);

from prynt import PryntServer

prynt = PryntServer(secret_key=os.environ["PRYNT_SECRET_KEY"])

# Create rule (disabled) and backtest
rule = prynt.rules.create(
    name="High-risk ATO block",
    conditions=[
        {"field": "scores.ato", "op": "gt", "value": 0.7},
        {"field": "signals.vpn.detected", "op": "eq", "value": True},
    ],
    action="block",
    enabled=False,
)

backtest = prynt.rules.backtest(rule.id, days=7)

print(f"Analyzed: {backtest.total_events} events")
print(f"Matched:  {backtest.matched_events} events")
print(f"Rate:     {backtest.match_rate}")