API Reference

{
  "risk_score": 45,
  "action": "soft_challenge",
  "reason": [
    "behavior_shift_detected",
    "typing_speed_changed",
    "uniform_typing_pattern"
  ],
  "session_id": "session-uuid",
  "request_id": "request-uuid",
  "score": 0.45,
  
  // Behavioral change analysis
  "behavior_change": {
    "baseline_available": true,
    "behavior_changed": true,
    "change_score": 35.5,
    "change_reasons": [
      "typing_speed_changed",
      "mouse_pattern_changed"
    ],
    "similarity_score": 62.3
  },
  
  // Adaptive response recommendations
  "adaptive_response": {
    "recommended_action": "soft_challenge",
    "challenges": ["mfa", "captcha"],
    "reason": "Behavior change detected during registration",
    "confidence": 0.85
  }
}

// React example
import { useKeverdContext } from '@keverdjs/fraud-sdk-react';

function RegistrationForm() {
  const { verifyRegistration } = useKeverdContext();
  const [step, setStep] = useState('form');
  
  const handleSubmit = async (formData) => {
    try {
      // Verify registration with behavioral monitoring
      const result = await verifyRegistration({
        email: formData.email,
        username: formData.username
      });
      
      // Check risk level
      if (result.action === "block") {
        // Block registration
        showError("Registration blocked. Please contact support.");
        return;
      }
      
      if (result.action === "hard_challenge") {
        // Require multiple verifications
        setStep('challenge');
        await showCaptcha();
        await sendEmailVerification(formData.email);
        await sendSMSVerification(formData.phone);
        return;
      }
      
      if (result.action === "soft_challenge") {
        // Check recommended challenges
        const challenges = result.adaptive_response?.challenges || [];
        
        if (challenges.includes("captcha")) {
          await showCaptcha();
        }
        
        if (challenges.includes("mfa")) {
          await sendEmailVerification(formData.email);
        }
        
        // Re-verify after challenges
        const recheck = await verifyRegistration();
        if (recheck.action !== "allow") {
          showError("Verification failed. Please try again.");
          return;
        }
      }
      
      // Behavior change detected?
      if (result.behavior_change?.behavior_changed) {
        console.warn("Behavior change detected:", result.behavior_change.change_reasons);
        // Log for review or require additional verification
        if (result.behavior_change.change_score > 50) {
          await sendEmailVerification(formData.email);
        }
      }
      
      // Proceed with registration
      await createUserAccount(formData);
      showSuccess("Account created successfully!");
      
    } catch (error) {
      console.error("Registration verification failed:", error);
      showError("Registration failed. Please try again.");
    }
  };
  
  return (
    // Your registration form JSX
  );
}

import { Keverd } from '@keverdjs/fraud-sdk';

async function handleLogin(email, password) {
  try {
    // Verify login attempt
    const result = await Keverd.verifyLogin(email);
    
    if (result.action === 'block') {
      // Block login - potential account takeover
      showError('Login blocked due to security concerns');
      logSecurityEvent('blocked_login', { email, result });
      return;
    }
    
    // Proceed with authentication
    const authResult = await authenticateUser(email, password);
    
    if (!authResult.success) {
      return;
    }
    
    // If high risk, require MFA even after successful password
    if (result.action === 'hard_challenge') {
      const mfaValid = await requestMFA();
      if (!mfaValid) {
        showError('MFA verification failed');
        return;
      }
    }
    
    // Login successful
    redirectToDashboard();
    
  } catch (error) {
    console.error('Login verification failed:', error);
    showError('Login failed. Please try again.');
  }
}

import { Keverd } from '@keverdjs/fraud-sdk';

async function handleCheckout(cart, paymentMethod) {
  try {
    // Verify checkout
    const result = await Keverd.verifyCheckout(
      cart.total,
      cart.currency,
      {
        paymentMethod: paymentMethod.type,
        cardLast4: paymentMethod.last4,
        items: cart.items.length
      }
    );
    
    if (result.action === 'block') {
      // Block transaction
      showError('Transaction blocked due to security concerns');
      logSecurityEvent('blocked_transaction', { amount: cart.total, result });
      return;
    }
    
    if (result.action === 'hard_challenge') {
      // Require payment verification
      const verified = await requestPayment2FA();
      if (!verified) {
        showError('Payment verification failed');
        return;
      }
    }
    
    // Proceed with payment
    const paymentResult = await processPayment(cart, paymentMethod);
    if (paymentResult.success) {
      showSuccess('Payment processed successfully!');
    }
    
  } catch (error) {
    console.error('Checkout verification failed:', error);
    showError('Payment failed. Please try again.');
  }
}

import { Keverd } from '@keverdjs/fraud-sdk';

async function handlePasswordReset(email) {
  try {
    // Verify password reset request
    const result = await Keverd.verifyPasswordReset(email);
    
    if (result.action === 'block') {
      // Block password reset - potential account takeover
      showError('Password reset blocked. Please contact support.');
      logSecurityEvent('blocked_password_reset', { email, result });
      return;
    }
    
    if (result.action === 'hard_challenge') {
      // Require additional verification
      const verified = await sendVerificationCode(email);
      if (!verified) {
        showError('Verification failed');
        return;
      }
    }
    
    // Send password reset email
    await sendPasswordResetEmail(email);
    showSuccess('Password reset email sent!');
    
  } catch (error) {
    console.error('Password reset verification failed:', error);
    showError('Password reset failed. Please try again.');
  }
}

import { Keverd } from '@keverdjs/fraud-sdk';

async function handleEmailChange(currentEmail, newEmail) {
  try {
    // Verify account change
    const result = await Keverd.verifyAccountChange('email', {
      oldEmail: currentEmail,
      newEmail: newEmail
    });
    
    if (result.action === 'block') {
      showError('Email change blocked. Please contact support.');
      return;
    }
    
    if (result.action === 'hard_challenge') {
      // Require verification from both emails
      await sendVerificationCode(currentEmail);
      await sendVerificationCode(newEmail);
      
      const bothVerified = await verifyBothCodes();
      if (!bothVerified) {
        showError('Verification failed');
        return;
      }
    }
    
    // Proceed with email change
    await updateUserEmail(newEmail);
    showSuccess('Email updated successfully!');
    
  } catch (error) {
    console.error('Account change verification failed:', error);
    showError('Email change failed. Please try again.');
  }
}