Best Shopify Phone Validation API & Checkout Verification Integration 2025

const express = require('express');
const { Shopify } = require('@shopify/shopify-api');
const fetch = require('node-fetch');

const app = express();
app.use(express.json());

// 1lookup API configuration
const LOOKUP_API_KEY = process.env.LOOKUP_API_KEY;
const LOOKUP_BASE_URL = 'https://app.1lookup.io/api/v1';

// Validate phone number using 1lookup
async function validatePhone(phoneNumber) {
  try {
    const response = await fetch(`${LOOKUP_BASE_URL}/phone`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${LOOKUP_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ phone: phoneNumber })
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status}`);
    }
    
    const data = await response.json();
    return data.data;
  } catch (error) {
    console.error('Phone validation error:', error);
    return null;
  }
}

// Validate email using 1lookup
async function validateEmail(email) {
  try {
    const response = await fetch(`${LOOKUP_BASE_URL}/email`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${LOOKUP_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ email: email })
    });
    
    if (!response.ok) {
      throw new Error(`API error: ${response.status}`);
    }
    
    const data = await response.json();
    return data.data;
  } catch (error) {
    console.error('Email validation error:', error);
    return null;
  }
}

// Order validation endpoint
app.post('/api/validate-order', async (req, res) => {
  const { shop, orderId, customer } = req.body;
  
  try {
    const validationResults = {
      order_id: orderId,
      phone_valid: false,
      email_valid: false,
      risk_level: 'unknown',
      carrier_info: null,
      location_info: null
    };
    
    // Validate phone number if provided
    if (customer.phone) {
      const phoneValidation = await validatePhone(customer.phone);
      if (phoneValidation) {
        validationResults.phone_valid = phoneValidation.classification.is_valid;
        validationResults.carrier_info = phoneValidation.carrier_details;
        validationResults.location_info = phoneValidation.location_details;
        validationResults.risk_level = phoneValidation.risk_assessment?.risk_level || 'low';
      }
    }
    
    // Validate email if provided
    if (customer.email) {
      const emailValidation = await validateEmail(customer.email);
      if (emailValidation) {
        validationResults.email_valid = emailValidation.classification.is_valid;
        if (emailValidation.risk_assessment?.risk_level) {
          validationResults.risk_level = emailValidation.risk_assessment.risk_level;
        }
      }
    }
    
    // Update order with validation results
    await updateOrderMetafields(shop, orderId, validationResults);
    
    res.json({
      success: true,
      validation: validationResults
    });
    
  } catch (error) {
    console.error('Order validation error:', error);
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// Update Shopify order with validation metafields
async function updateOrderMetafields(shop, orderId, validationResults) {
  const client = new Shopify.Clients.Rest(shop, process.env.SHOPIFY_ACCESS_TOKEN);
  
  const metafields = [
    {
      namespace: 'validation',
      key: 'phone_valid',
      value: validationResults.phone_valid.toString(),
      type: 'boolean'
    },
    {
      namespace: 'validation',
      key: 'email_valid',
      value: validationResults.email_valid.toString(),
      type: 'boolean'
    },
    {
      namespace: 'validation',
      key: 'risk_level',
      value: validationResults.risk_level,
      type: 'single_line_text_field'
    }
  ];
  
  if (validationResults.carrier_info) {
    metafields.push({
      namespace: 'validation',
      key: 'carrier_name',
      value: validationResults.carrier_info.name || '',
      type: 'single_line_text_field'
    });
  }
  
  for (const metafield of metafields) {
    try {
      await client.post({
        path: `orders/${orderId}/metafields`,
        data: { metafield }
      });
    } catch (error) {
      console.error('Metafield update error:', error);
    }
  }
}

app.listen(3000, () => {
  console.log('Shopify validation app listening on port 3000');
});

// Add to theme.liquid or checkout.liquid
(function() {
  'use strict';
  
  const VALIDATION_API_ENDPOINT = 'https://your-app.herokuapp.com/api/validate-contact';
  
  class CheckoutValidator {
    constructor() {
      this.debounceTimer = null;
      this.validationCache = new Map();
      this.init();
    }
    
    init() {
      // Wait for Shopify checkout to load
      if (typeof Shopify !== 'undefined' && Shopify.Checkout) {
        this.bindEvents();
      } else {
        setTimeout(() => this.init(), 500);
      }
    }
    
    bindEvents() {
      const phoneInput = document.querySelector('input[name="checkout[shipping_address][phone]"]') ||
                        document.querySelector('input[name="checkout[billing_address][phone]"]');
      const emailInput = document.querySelector('input[name="checkout[email]"]');
      
      if (phoneInput) {
        phoneInput.addEventListener('blur', (e) => this.validatePhone(e.target));
        phoneInput.addEventListener('input', (e) => this.debouncedValidation(e.target, 'phone'));
      }
      
      if (emailInput) {
        emailInput.addEventListener('blur', (e) => this.validateEmail(e.target));
        emailInput.addEventListener('input', (e) => this.debouncedValidation(e.target, 'email'));
      }
      
      // Validate before checkout submission
      const checkoutForm = document.querySelector('form[data-customer-form]') ||
                          document.querySelector('.edit_checkout');
      if (checkoutForm) {
        checkoutForm.addEventListener('submit', (e) => this.validateBeforeSubmit(e));
      }
    }
    
    debouncedValidation(input, type) {
      clearTimeout(this.debounceTimer);
      this.debounceTimer = setTimeout(() => {
        if (type === 'phone') {
          this.validatePhone(input);
        } else if (type === 'email') {
          this.validateEmail(input);
        }
      }, 1000);
    }
    
    async validatePhone(input) {
      const phoneNumber = input.value.trim();
      if (!phoneNumber || phoneNumber.length < 10) return;
      
      // Check cache first
      if (this.validationCache.has(phoneNumber)) {
        this.displayPhoneValidation(input, this.validationCache.get(phoneNumber));
        return;
      }
      
      this.showValidationLoading(input, 'phone');
      
      try {
        const response = await fetch(VALIDATION_API_ENDPOINT, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'X-Shopify-Shop-Domain': Shopify.shop
          },
          body: JSON.stringify({
            type: 'phone',
            value: phoneNumber
          })
        });
        
        const result = await response.json();
        this.validationCache.set(phoneNumber, result);
        this.displayPhoneValidation(input, result);
        
      } catch (error) {
        console.error('Phone validation error:', error);
        this.hideValidationMessage(input);
      }
    }
    
    async validateEmail(input) {
      const email = input.value.trim();
      if (!email || !this.isValidEmailFormat(email)) return;
      
      // Check cache first
      if (this.validationCache.has(email)) {
        this.displayEmailValidation(input, this.validationCache.get(email));
        return;
      }
      
      this.showValidationLoading(input, 'email');
      
      try {
        const response = await fetch(VALIDATION_API_ENDPOINT, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'X-Shopify-Shop-Domain': Shopify.shop
          },
          body: JSON.stringify({
            type: 'email',
            value: email
          })
        });
        
        const result = await response.json();
        this.validationCache.set(email, result);
        this.displayEmailValidation(input, result);
        
      } catch (error) {
        console.error('Email validation error:', error);
        this.hideValidationMessage(input);
      }
    }
    
    displayPhoneValidation(input, result) {
      this.hideValidationMessage(input);
      
      const messageDiv = this.createValidationMessage(input);
      
      if (result.valid) {
        messageDiv.className = 'validation-message success';
        messageDiv.innerHTML = `
          <span class="validation-icon">✓</span>
          <span>Phone number verified</span>
          ${result.carrier ? `<small> • ${result.carrier}</small>` : ''}
        `;
      } else {
        messageDiv.className = 'validation-message error';
        messageDiv.innerHTML = `
          <span class="validation-icon">⚠</span>
          <span>Please enter a valid phone number</span>
        `;
      }
      
      if (result.risk_level === 'high') {
        messageDiv.className = 'validation-message warning';
        messageDiv.innerHTML = `
          <span class="validation-icon">⚠</span>
          <span>This phone number appears to be high risk</span>
        `;
      }
    }
    
    displayEmailValidation(input, result) {
      this.hideValidationMessage(input);
      
      const messageDiv = this.createValidationMessage(input);
      
      if (result.valid) {
        messageDiv.className = 'validation-message success';
        messageDiv.innerHTML = `
          <span class="validation-icon">✓</span>
          <span>Email address verified</span>
        `;
      } else {
        messageDiv.className = 'validation-message error';
        messageDiv.innerHTML = `
          <span class="validation-icon">⚠</span>
          <span>Please enter a valid email address</span>
        `;
      }
    }
    
    createValidationMessage(input) {
      let messageDiv = input.parentNode.querySelector('.validation-message');
      if (!messageDiv) {
        messageDiv = document.createElement('div');
        messageDiv.className = 'validation-message';
        input.parentNode.appendChild(messageDiv);
      }
      return messageDiv;
    }
    
    showValidationLoading(input, type) {
      const messageDiv = this.createValidationMessage(input);
      messageDiv.className = 'validation-message loading';
      messageDiv.innerHTML = `
        <span class="validation-spinner"></span>
        <span>Validating ${type}...</span>
      `;
    }
    
    hideValidationMessage(input) {
      const messageDiv = input.parentNode.querySelector('.validation-message');
      if (messageDiv) {
        messageDiv.remove();
      }
    }
    
    isValidEmailFormat(email) {
      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
      return emailRegex.test(email);
    }
    
    async validateBeforeSubmit(event) {
      const phoneInput = document.querySelector('input[name="checkout[shipping_address][phone]"]') ||
                        document.querySelector('input[name="checkout[billing_address][phone]"]');
      const emailInput = document.querySelector('input[name="checkout[email]"]');
      
      let hasErrors = false;
      
      // Check for existing validation errors
      const errorMessages = document.querySelectorAll('.validation-message.error');
      if (errorMessages.length > 0) {
        hasErrors = true;
      }
      
      if (hasErrors) {
        event.preventDefault();
        this.showCheckoutError('Please correct the validation errors before proceeding.');
        return false;
      }
      
      return true;
    }
    
    showCheckoutError(message) {
      // Show error message in Shopify's standard error location
      const errorDiv = document.querySelector('.errors') || 
                      document.querySelector('[data-banner-type="error"]');
      if (errorDiv) {
        errorDiv.innerHTML = `<p>${message}</p>`;
        errorDiv.style.display = 'block';
        errorDiv.scrollIntoView({ behavior: 'smooth' });
      }
    }
  }
  
  // Initialize when DOM is ready
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', () => new CheckoutValidator());
  } else {
    new CheckoutValidator();
  }
})();

/* Add to your theme's CSS */
.validation-message {
  margin-top: 8px;
  padding: 8px 12px;
  border-radius: 4px;
  font-size: 14px;
  display: flex;
  align-items: center;
  gap: 8px;
}

.validation-message.success {
  background-color: #d4edda;
  color: #155724;
  border: 1px solid #c3e6cb;
}

.validation-message.error {
  background-color: #f8d7da;
  color: #721c24;
  border: 1px solid #f5c6cb;
}

.validation-message.warning {
  background-color: #fff3cd;
  color: #856404;
  border: 1px solid #ffeaa7;
}

.validation-message.loading {
  background-color: #e2e3e5;
  color: #6c757d;
  border: 1px solid #d6d8db;
}

.validation-icon {
  font-weight: bold;
}

.validation-spinner {
  width: 16px;
  height: 16px;
  border: 2px solid #f3f3f3;
  border-top: 2px solid #007bff;
  border-radius: 50%;
  animation: spin 1s linear infinite;
}

@keyframes spin {
  0% { transform: rotate(0deg); }
  100% { transform: rotate(360deg); }
}

.validation-message small {
  opacity: 0.8;
  font-size: 12px;
}

// Webhook endpoint for order/created
app.post('/webhooks/orders/created', express.raw({type: 'application/json'}), async (req, res) => {
  const hmac = req.get('X-Shopify-Hmac-Sha256');
  const body = req.body;
  const hash = crypto
    .createHmac('sha256', process.env.SHOPIFY_WEBHOOK_SECRET)
    .update(body, 'utf8')
    .digest('base64');

  if (hash !== hmac) {
    return res.status(401).send('Unauthorized');
  }

  const order = JSON.parse(body);
  
  try {
    await validateAndProcessOrder(order);
    res.status(200).send('OK');
  } catch (error) {
    console.error('Order validation error:', error);
    res.status(500).send('Error');
  }
});

async function validateAndProcessOrder(order) {
  const validationResults = {
    order_id: order.id,
    customer_id: order.customer?.id,
    phone_validation: null,
    email_validation: null,
    risk_score: 0,
    should_flag: false
  };
  
  // Validate shipping phone
  if (order.shipping_address?.phone) {
    const phoneValidation = await validatePhone(order.shipping_address.phone);
    if (phoneValidation) {
      validationResults.phone_validation = {
        phone: order.shipping_address.phone,
        is_valid: phoneValidation.classification.is_valid,
        carrier: phoneValidation.carrier_details?.name,
        line_type: phoneValidation.carrier_details?.type,
        risk_level: phoneValidation.risk_assessment?.risk_level,
        location: phoneValidation.location_details?.city
      };
      
      // Increase risk score for invalid or high-risk phones
      if (!phoneValidation.classification.is_valid) {
        validationResults.risk_score += 30;
      }
      if (phoneValidation.risk_assessment?.risk_level === 'high') {
        validationResults.risk_score += 40;
      }
    }
  }
  
  // Validate customer email
  if (order.customer?.email) {
    const emailValidation = await validateEmail(order.customer.email);
    if (emailValidation) {
      validationResults.email_validation = {
        email: order.customer.email,
        is_valid: emailValidation.classification.is_valid,
        is_deliverable: emailValidation.classification.is_deliverable,
        risk_level: emailValidation.risk_assessment?.risk_level
      };
      
      // Increase risk score for invalid or high-risk emails
      if (!emailValidation.classification.is_valid) {
        validationResults.risk_score += 25;
      }
      if (emailValidation.risk_assessment?.risk_level === 'high') {
        validationResults.risk_score += 35;
      }
    }
  }
  
  // Flag high-risk orders
  if (validationResults.risk_score >= 50) {
    validationResults.should_flag = true;
    await flagOrderForReview(order.id, validationResults);
  }
  
  // Store validation results
  await storeValidationResults(order.id, validationResults);
  
  // Update order tags based on validation
  await updateOrderTags(order.id, validationResults);
  
  return validationResults;
}

async function flagOrderForReview(orderId, validationResults) {
  const client = new Shopify.Clients.Rest(shop, process.env.SHOPIFY_ACCESS_TOKEN);
  
  // Add fraud review note
  const note = `Order flagged for review - Risk Score: ${validationResults.risk_score}
Phone Valid: ${validationResults.phone_validation?.is_valid || 'N/A'}
Email Valid: ${validationResults.email_validation?.is_valid || 'N/A'}
Risk Factors: ${generateRiskFactorsList(validationResults)}`;
  
  await client.post({
    path: `orders/${orderId}/events`,
    data: {
      event: {
        subject_type: 'Order',
        subject_id: orderId,
        verb: 'created',
        body: note
      }
    }
  });
}

async function updateOrderTags(orderId, validationResults) {
  const client = new Shopify.Clients.Rest(shop, process.env.SHOPIFY_ACCESS_TOKEN);
  
  const tags = [];
  
  if (validationResults.phone_validation) {
    if (validationResults.phone_validation.is_valid) {
      tags.push('phone-validated');
    } else {
      tags.push('phone-invalid');
    }
    
    if (validationResults.phone_validation.risk_level === 'high') {
      tags.push('phone-high-risk');
    }
  }
  
  if (validationResults.email_validation) {
    if (validationResults.email_validation.is_valid) {
      tags.push('email-validated');
    } else {
      tags.push('email-invalid');
    }
  }
  
  if (validationResults.should_flag) {
    tags.push('requires-review');
  }
  
  if (tags.length > 0) {
    await client.put({
      path: `orders/${orderId}`,
      data: {
        order: {
          id: orderId,
          tags: tags.join(', ')
        }
      }
    });
  }
}

function generateRiskFactorsList(validationResults) {
  const factors = [];
  
  if (validationResults.phone_validation && !validationResults.phone_validation.is_valid) {
    factors.push('Invalid phone number');
  }
  
  if (validationResults.email_validation && !validationResults.email_validation.is_valid) {
    factors.push('Invalid email address');
  }
  
  if (validationResults.phone_validation?.risk_level === 'high') {
    factors.push('High-risk phone number');
  }
  
  if (validationResults.email_validation?.risk_level === 'high') {
    factors.push('High-risk email address');
  }
  
  return factors.length > 0 ? factors.join(', ') : 'None detected';
}

// Frontend validation for customer registration
class CustomerRegistrationValidator {
  constructor() {
    this.apiEndpoint = 'https://your-validation-service.com/api';
    this.bindEvents();
  }
  
  bindEvents() {
    const registerForm = document.querySelector('#create_customer');
    if (registerForm) {
      const phoneInput = registerForm.querySelector('input[name="customer[phone]"]');
      const emailInput = registerForm.querySelector('input[name="customer[email]"]');
      
      if (phoneInput) {
        phoneInput.addEventListener('blur', (e) => this.validatePhone(e.target));
      }
      
      if (emailInput) {
        emailInput.addEventListener('blur', (e) => this.validateEmail(e.target));
      }
      
      registerForm.addEventListener('submit', (e) => this.validateBeforeSubmit(e));
    }
  }
  
  async validatePhone(input) {
    const phone = input.value.trim();
    if (!phone) return;
    
    try {
      const response = await fetch(`${this.apiEndpoint}/validate-phone`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ phone })
      });
      
      const result = await response.json();
      this.displayValidationResult(input, result, 'phone');
      
    } catch (error) {
      console.error('Phone validation error:', error);
    }
  }
  
  async validateEmail(input) {
    const email = input.value.trim();
    if (!email) return;
    
    try {
      const response = await fetch(`${this.apiEndpoint}/validate-email`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ email })
      });
      
      const result = await response.json();
      this.displayValidationResult(input, result, 'email');
      
    } catch (error) {
      console.error('Email validation error:', error);
    }
  }
  
  displayValidationResult(input, result, type) {
    // Remove existing validation message
    const existingMessage = input.parentNode.querySelector('.validation-message');
    if (existingMessage) {
      existingMessage.remove();
    }
    
    const messageDiv = document.createElement('div');
    messageDiv.className = 'validation-message';
    
    if (result.valid) {
      messageDiv.className += ' success';
      messageDiv.textContent = `${type === 'phone' ? 'Phone' : 'Email'} verified successfully`;
    } else {
      messageDiv.className += ' error';
      messageDiv.textContent = `Please enter a valid ${type === 'phone' ? 'phone number' : 'email address'}`;
      input.classList.add('error');
    }
    
    input.parentNode.appendChild(messageDiv);
  }
  
  async validateBeforeSubmit(event) {
    const errorMessages = document.querySelectorAll('.validation-message.error');
    if (errorMessages.length > 0) {
      event.preventDefault();
      
      // Scroll to first error
      errorMessages[0].scrollIntoView({ behavior: 'smooth' });
      
      // Show general error message
      this.showFormError('Please correct the validation errors before continuing.');
      
      return false;
    }
  }
  
  showFormError(message) {
    let errorDiv = document.querySelector('.form-validation-error');
    if (!errorDiv) {
      errorDiv = document.createElement('div');
      errorDiv.className = 'form-validation-error alert alert-error';
      
      const form = document.querySelector('#create_customer');
      form.insertBefore(errorDiv, form.firstChild);
    }
    
    errorDiv.textContent = message;
    errorDiv.style.display = 'block';
  }
}

// Initialize when DOM is ready
if (document.readyState === 'loading') {
  document.addEventListener('DOMContentLoaded', () => new CustomerRegistrationValidator());
} else {
  new CustomerRegistrationValidator();
}