Best Mixpanel Analytics Phone Validation API & Email Verification Integration 2025

// Initialize Mixpanel with 1lookup validation
import mixpanel from 'mixpanel-browser';

// Configure Mixpanel
mixpanel.init('YOUR_MIXPANEL_PROJECT_TOKEN');

// Enhanced event tracking with contact validation
async function trackEventWithValidation(eventName, properties) {
  try {
    // Validate contact information if present
    if (properties.phone || properties.email) {
      const validationData = await validateContact({
        phone: properties.phone,
        email: properties.email
      });
      
      // Enhance properties with validation results
      const enhancedProperties = {
        ...properties,
        phone_validation_status: validationData.phone?.is_valid,
        phone_carrier: validationData.phone?.carrier_details?.name,
        phone_risk_level: validationData.phone?.risk_assessment?.risk_level,
        email_validation_status: validationData.email?.is_valid,
        email_risk_level: validationData.email?.risk_assessment?.risk_level,
        contact_quality_score: calculateQualityScore(validationData)
      };
      
      // Track enhanced event
      mixpanel.track(eventName, enhancedProperties);
    } else {
      // Track normal event
      mixpanel.track(eventName, properties);
    }
  } catch (error) {
    console.error('Validation error:', error);
    // Fallback to normal tracking
    mixpanel.track(eventName, properties);
  }
}

// Validation function
async function validateContact(contactData) {
  const response = await fetch('https://app.1lookup.io/api/v1/validate', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(contactData)
  });
  
  return await response.json();
}

const Mixpanel = require('mixpanel');
const mixpanel = Mixpanel.init('YOUR_MIXPANEL_PROJECT_TOKEN');

// Enhanced user profile update with validation
async function updateUserProfileWithValidation(userId, profileData) {
  try {
    // Validate contact information
    const validation = await validateUserContact(profileData);
    
    // Prepare enhanced profile data
    const enhancedProfile = {
      ...profileData,
      $phone_validation_status: validation.phone?.is_valid ? 'Valid' : 'Invalid',
      $phone_carrier: validation.phone?.carrier_details?.name || '',
      $phone_line_type: validation.phone?.carrier_details?.type || '',
      $phone_risk_level: validation.phone?.risk_assessment?.risk_level || '',
      $email_validation_status: validation.email?.is_valid ? 'Valid' : 'Invalid',
      $email_deliverability: validation.email?.deliverability?.status || '',
      $email_risk_level: validation.email?.risk_assessment?.risk_level || '',
      $contact_quality_score: calculateContactQuality(validation),
      $validation_timestamp: new Date().toISOString()
    };
    
    // Update Mixpanel user profile
    mixpanel.people.set(userId, enhancedProfile);
    
    // Track validation event for analytics
    mixpanel.track('Contact Validated', {
      distinct_id: userId,
      validation_type: 'profile_update',
      phone_valid: validation.phone?.is_valid,
      email_valid: validation.email?.is_valid,
      quality_score: enhancedProfile.$contact_quality_score
    });
    
    return { success: true, validation };
  } catch (error) {
    console.error('Profile validation error:', error);
    return { success: false, error: error.message };
  }
}

// Enhanced conversion tracking with validation analytics
class MixpanelValidationTracker {
  constructor(mixpanelToken, lookupApiKey) {
    this.mixpanel = mixpanel;
    this.apiKey = lookupApiKey;
    mixpanel.init(mixpanelToken);
  }
  
  async trackConversion(conversionType, userEmail, userPhone, conversionValue) {
    try {
      // Validate contact information
      const validation = await this.validateContact(userEmail, userPhone);
      
      // Calculate conversion quality score
      const qualityScore = this.calculateConversionQuality(validation);
      
      // Enhanced conversion event
      const conversionEvent = {
        conversion_type: conversionType,
        conversion_value: conversionValue,
        email: userEmail,
        phone: userPhone,
        // Validation insights
        email_valid: validation.email?.is_valid,
        email_deliverability: validation.email?.deliverability?.status,
        email_risk_level: validation.email?.risk_assessment?.risk_level,
        phone_valid: validation.phone?.is_valid,
        phone_carrier: validation.phone?.carrier_details?.name,
        phone_line_type: validation.phone?.carrier_details?.type,
        phone_risk_level: validation.phone?.risk_assessment?.risk_level,
        // Analytics enhancement
        contact_quality_score: qualityScore,
        is_high_quality_conversion: qualityScore >= 80,
        fraud_risk_level: this.assessFraudRisk(validation),
        attribution_confidence: this.calculateAttributionConfidence(validation)
      };
      
      // Track the enhanced conversion
      mixpanel.track('Conversion', conversionEvent);
      
      // Track validation insights separately for analytics
      mixpanel.track('Contact Validation Insight', {
        validation_type: 'conversion_tracking',
        quality_score: qualityScore,
        has_fraud_indicators: conversionEvent.fraud_risk_level === 'high'
      });
      
    } catch (error) {
      console.error('Conversion tracking error:', error);
      // Fallback tracking
      mixpanel.track('Conversion', {
        conversion_type: conversionType,
        conversion_value: conversionValue,
        validation_error: true
      });
    }
  }
  
  calculateConversionQuality(validation) {
    let score = 0;
    
    if (validation.email?.is_valid) score += 40;
    if (validation.phone?.is_valid) score += 40;
    if (validation.email?.deliverability?.status === 'deliverable') score += 10;
    if (validation.phone?.risk_assessment?.risk_level === 'low') score += 10;
    
    return score;
  }
}

// Advanced customer journey tracking with validation insights
class CustomerJourneyTracker {
  constructor(mixpanelToken, lookupApiKey) {
    this.mixpanel = mixpanel;
    this.apiKey = lookupApiKey;
    mixpanel.init(mixpanelToken);
  }
  
  async trackJourneyStage(userId, stage, contactInfo, additionalData = {}) {
    try {
      // Validate contact at each journey stage
      const validation = await this.validateContact(contactInfo);
      
      // Calculate journey stage quality
      const stageQuality = this.calculateStageQuality(stage, validation);
      
      // Enhanced journey event
      const journeyEvent = {
        user_id: userId,
        journey_stage: stage,
        stage_quality_score: stageQuality,
        // Contact validation data
        email_valid: validation.email?.is_valid,
        email_deliverability: validation.email?.deliverability?.status,
        phone_valid: validation.phone?.is_valid,
        phone_carrier: validation.phone?.carrier_details?.name,
        phone_country: validation.phone?.location_details?.country,
        // Risk assessment
        overall_risk_level: this.calculateOverallRisk(validation),
        fraud_indicators: this.extractFraudIndicators(validation),
        // Journey analytics
        is_qualified_stage: stageQuality >= 70,
        stage_completion_confidence: this.calculateStageConfidence(validation),
        ...additionalData
      };
      
      // Track journey stage
      mixpanel.track('Journey Stage', journeyEvent);
      
      // Update user profile with latest validation data
      mixpanel.people.set(userId, {
        $last_validation_stage: stage,
        $contact_quality_score: stageQuality,
        $last_validation_date: new Date().toISOString()
      });
      
      // Track funnel progression
      this.trackFunnelProgression(userId, stage, stageQuality);
      
    } catch (error) {
      console.error('Journey tracking error:', error);
    }
  }
  
  async validateContact(contactInfo) {
    const response = await fetch('https://app.1lookup.io/api/v1/validate', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(contactInfo)
    });
    
    return await response.json();
  }
  
  calculateStageQuality(stage, validation) {
    const baseScore = validation.email?.is_valid ? 50 : 0;
    const phoneScore = validation.phone?.is_valid ? 30 : 0;
    const riskPenalty = validation.email?.risk_assessment?.risk_level === 'high' ? -20 : 0;
    
    // Stage-specific scoring
    const stageMultipliers = {
      'registration': 1.0,
      'email_verification': 1.2,
      'profile_completion': 1.1,
      'first_purchase': 1.3,
      'repeat_customer': 1.4
    };
    
    return Math.max(0, (baseScore + phoneScore + riskPenalty) * (stageMultipliers[stage] || 1.0));
  }
}