Best Hotjar Behavior Analytics Phone Validation API & Email Verification Integration 2025

// Enhanced Hotjar integration with 1lookup validation
(function() {
  // Initialize Hotjar tracking
  (function(h,o,t,j,a,r){
    h.hj=h.hj||function(){(h.hj.q=h.hj.q||[]).push(arguments)};
    h._hjSettings={hjid:YOUR_HOTJAR_ID,hjsv:6};
    a=o.getElementsByTagName('head')[0];
    r=o.createElement('script');r.async=1;
    r.src=t+h._hjSettings.hjid+j+h._hjSettings.hjsv;
    a.appendChild(r);
  })(window,document,'https://static.hotjar.com/c/hotjar-','.js?sv=');

  // Enhanced user identification with contact validation
  window.identifyUserWithValidation = async function(userId, userAttributes) {
    try {
      // Validate user contact information if present
      if (userAttributes.email || userAttributes.phone) {
        const validationData = await validateUserContactForHotjar({
          phone: userAttributes.phone,
          email: userAttributes.email
        });
        
        // Enhance user attributes with validation results
        const enhancedAttributes = {
          ...userAttributes,
          // Phone validation attributes
          phone_validation_status: validationData.phone?.is_valid,
          phone_carrier: validationData.phone?.carrier_details?.name,
          phone_line_type: validationData.phone?.carrier_details?.type,
          phone_country: validationData.phone?.location_details?.country,
          phone_risk_level: validationData.phone?.risk_assessment?.risk_level,
          // Email validation attributes
          email_validation_status: validationData.email?.is_valid,
          email_deliverability: validationData.email?.deliverability?.status,
          email_domain_type: validationData.email?.domain_details?.type,
          email_risk_level: validationData.email?.risk_assessment?.risk_level,
          // UX-specific enhancements
          user_quality_score: calculateUXUserQualityScore(validationData),
          user_quality_tier: determineUXUserTier(validationData),
          is_verified_user: isVerifiedUXUser(validationData),
          session_validation_timestamp: new Date().toISOString(),
          // Hotjar-specific attributes
          hotjar_user_validation_version: '2025.1',
          ux_research_segment: determineUXResearchSegment(validationData)
        };
        
        // Identify user with enhanced attributes in Hotjar
        hj('identify', userId, enhancedAttributes);
        
        // Track validation event for UX analytics
        hj('event', 'user_contact_validated');
        
        // Set user tags for better segmentation
        const userTags = generateUXUserTags(validationData);
        userTags.forEach(tag => hj('tagRecording', [tag]));
        
      } else {
        // Standard identification without validation
        hj('identify', userId, userAttributes);
      }
      
    } catch (error) {
      console.error('Hotjar user validation error:', error);
      // Fallback to standard identification
      hj('identify', userId, {
        ...userAttributes,
        validation_error: true,
        validation_error_message: error.message
      });
    }
  };

  // Contact validation function optimized for UX research
  async function validateUserContactForHotjar(contactData) {
    const response = await fetch('https://app.1lookup.io/api/v1/validate', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer YOUR_1LOOKUP_API_KEY',
        'Content-Type': 'application/json',
        'X-Integration': 'hotjar-ux'
      },
      body: JSON.stringify({
        ...contactData,
        include_carrier_details: true,
        include_location_details: true,
        include_risk_assessment: true,
        ux_research_context: true
      })
    });
    
    if (!response.ok) {
      throw new Error(`UX validation failed: ${response.status}`);
    }
    
    return await response.json();
  }

  // Calculate UX-specific user quality score
  function calculateUXUserQualityScore(validationData) {
    let score = 0;
    
    // Email scoring for UX research
    if (validationData.email?.is_valid) score += 40;
    if (validationData.email?.deliverability?.status === 'deliverable') score += 15;
    
    // Phone scoring for UX research
    if (validationData.phone?.is_valid) score += 35;
    if (validationData.phone?.risk_assessment?.risk_level === 'low') score += 10;
    
    return Math.min(100, score);
  }

  // Determine UX research user tier
  function determineUXUserTier(validationData) {
    const qualityScore = calculateUXUserQualityScore(validationData);
    
    if (qualityScore >= 80) return 'premium_ux_user';
    if (qualityScore >= 60) return 'standard_ux_user';
    if (qualityScore >= 40) return 'basic_ux_user';
    return 'unverified_ux_user';
  }

  // Generate user tags for Hotjar session recording
  function generateUXUserTags(validationData) {
    const tags = [];
    
    if (validationData.phone?.is_valid) tags.push('verified-phone');
    if (validationData.email?.is_valid) tags.push('verified-email');
    
    const riskLevel = validationData.phone?.risk_assessment?.risk_level || 
                     validationData.email?.risk_assessment?.risk_level;
    if (riskLevel) tags.push(`risk-${riskLevel}`);
    
    const country = validationData.phone?.location_details?.country;
    if (country) tags.push(`country-${country.toLowerCase()}`);
    
    return tags;
  }

})();

// Enhanced Hotjar survey integration with contact validation
class HotjarFeedbackValidator {
  constructor(hotjarId, lookupApiKey) {
    this.hotjarId = hotjarId;
    this.lookupApiKey = lookupApiKey;
    this.initializeHotjar();
  }
  
  initializeHotjar() {
    // Standard Hotjar initialization
    (function(h,o,t,j,a,r){
      h.hj=h.hj||function(){(h.hj.q=h.hj.q||[]).push(arguments)};
      h._hjSettings={hjid:this.hotjarId,hjsv:6};
      a=o.getElementsByTagName('head')[0];
      r=o.createElement('script');r.async=1;
      r.src=t+h._hjSettings.hjid+j+h._hjSettings.hjsv;
      a.appendChild(r);
    })(window,document,'https://static.hotjar.com/c/hotjar-','.js?sv=');
  }
  
  async validateAndSubmitFeedback(feedbackData) {
    try {
      // Extract contact information from feedback
      const contactInfo = this.extractContactFromFeedback(feedbackData);
      
      if (contactInfo.phone || contactInfo.email) {
        // Validate contact information
        const validation = await this.validateFeedbackContact(contactInfo);
        
        // Enhance feedback with validation insights
        const enhancedFeedback = {
          ...feedbackData,
          // Contact validation results
          contact_validation_status: this.getFeedbackValidationStatus(validation),
          user_quality_score: this.calculateFeedbackUserQuality(validation),
          user_verification_level: this.getFeedbackVerificationLevel(validation),
          // Geographic and demographic insights
          user_country: validation.phone?.location_details?.country || '',
          user_region: validation.phone?.location_details?.region || '',
          user_carrier_type: validation.phone?.carrier_details?.type || '',
          email_domain_reputation: validation.email?.domain_details?.reputation || '',
          // Feedback quality indicators
          feedback_reliability_score: this.calculateFeedbackReliability(validation),
          is_high_quality_feedback: this.isHighQualityFeedback(validation),
          feedback_authenticity_level: this.getFeedbackAuthenticity(validation),
          // Validation metadata
          validation_timestamp: new Date().toISOString(),
          validation_confidence: this.getValidationConfidence(validation)
        };
        
        // Submit enhanced feedback to Hotjar
        this.submitEnhancedFeedbackToHotjar(enhancedFeedback);
        
        // Track feedback validation analytics
        hj('event', 'feedback_validated', {
          quality_score: enhancedFeedback.user_quality_score,
          verification_level: enhancedFeedback.user_verification_level,
          reliability_score: enhancedFeedback.feedback_reliability_score
        });
        
      } else {
        // Submit standard feedback without validation
        this.submitStandardFeedbackToHotjar(feedbackData);
      }
      
    } catch (error) {
      console.error('Feedback validation error:', error);
      // Submit feedback with error tracking
      this.submitStandardFeedbackToHotjar({
        ...feedbackData,
        validation_error: true,
        validation_error_details: error.message
      });
    }
  }
  
  async validateFeedbackContact(contactInfo) {
    const response = await fetch('https://app.1lookup.io/api/v1/validate', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.lookupApiKey}`,
        'Content-Type': 'application/json',
        'X-Integration': 'hotjar-feedback'
      },
      body: JSON.stringify({
        ...contactInfo,
        feedback_context: true,
        include_reputation_data: true
      })
    });
    
    return await response.json();
  }
  
  calculateFeedbackUserQuality(validation) {
    let score = 0;
    
    // Base contact validation
    if (validation.phone?.is_valid) score += 35;
    if (validation.email?.is_valid) score += 35;
    
    // Quality indicators for feedback
    if (validation.email?.deliverability?.status === 'deliverable') score += 15;
    if (validation.phone?.risk_assessment?.risk_level === 'low') score += 15;
    
    return Math.min(100, score);
  }
  
  calculateFeedbackReliability(validation) {
    const userQuality = this.calculateFeedbackUserQuality(validation);
    const riskPenalty = this.getRiskPenalty(validation);
    
    return Math.max(0, userQuality - riskPenalty);
  }
  
  isHighQualityFeedback(validation) {
    const reliabilityScore = this.calculateFeedbackReliability(validation);
    const hasValidContact = validation.phone?.is_valid || validation.email?.is_valid;
    const isLowRisk = (validation.phone?.risk_assessment?.risk_level === 'low') ||
                     (validation.email?.risk_assessment?.risk_level === 'low');
    
    return reliabilityScore >= 70 && hasValidContact && isLowRisk;
  }
  
  submitEnhancedFeedbackToHotjar(feedbackData) {
    // Submit feedback data through Hotjar's feedback API or events
    hj('event', 'enhanced_feedback_submitted');
    
    // Tag the recording with feedback quality indicators
    if (feedbackData.is_high_quality_feedback) {
      hj('tagRecording', ['high-quality-feedback']);
    }
    
    hj('tagRecording', [`feedback-quality-${feedbackData.user_verification_level}`]);
  }
}

// Advanced heatmap enhancement with user quality segmentation
class HotjarHeatmapEnhancer {
  constructor(lookupApiKey) {
    this.lookupApiKey = lookupApiKey;
    this.userValidationCache = new Map();
  }
  
  async enhanceHeatmapWithUserQuality(userId, interactionData) {
    try {
      // Get or validate user quality data
      let userValidation = this.userValidationCache.get(userId);
      if (!userValidation) {
        userValidation = await this.getUserValidationData(userId);
        this.userValidationCache.set(userId, userValidation);
      }
      
      // Calculate interaction quality score
      const interactionQuality = this.calculateInteractionQuality(
        interactionData, 
        userValidation
      );
      
      // Enhanced interaction tracking
      const enhancedInteraction = {
        ...interactionData,
        // User quality context
        user_quality_score: userValidation.quality_score,
        user_quality_tier: userValidation.tier,
        user_verification_status: userValidation.verification_status,
        // Interaction quality metrics
        interaction_quality_score: interactionQuality.score,
        interaction_weight: interactionQuality.weight,
        is_high_quality_interaction: interactionQuality.is_high_quality,
        interaction_reliability: interactionQuality.reliability,
        // Geographic and demographic context
        user_country: userValidation.country,
        user_region: userValidation.region,
        carrier_type: userValidation.carrier_type,
        device_trust_level: interactionQuality.device_trust,
        // Heatmap-specific enhancements
        heatmap_segment: this.determineHeatmapSegment(userValidation),
        click_authenticity_score: interactionQuality.authenticity_score,
        interaction_value_tier: interactionQuality.value_tier
      };
      
      // Apply heatmap segmentation tags
      const segmentTags = this.generateHeatmapTags(userValidation, interactionQuality);
      segmentTags.forEach(tag => hj('tagRecording', [tag]));
      
      // Track enhanced interaction for heatmap analytics
      hj('event', 'enhanced_heatmap_interaction', {
        quality_segment: enhancedInteraction.heatmap_segment,
        interaction_quality: enhancedInteraction.interaction_quality_score,
        user_tier: enhancedInteraction.user_quality_tier
      });
      
      return enhancedInteraction;
      
    } catch (error) {
      console.error('Heatmap enhancement error:', error);
      return {
        ...interactionData,
        enhancement_error: true,
        error_message: error.message
      };
    }
  }
  
  calculateInteractionQuality(interactionData, userValidation) {
    let score = 0;
    let weight = 1.0;
    let authenticityScore = 50;
    
    // Base user quality impact
    const userQuality = userValidation.quality_score || 0;
    score = userQuality * 0.6; // 60% weight from user quality
    
    // Interaction type scoring
    const interactionMultipliers = {
      'click': 1.0,
      'scroll': 0.8,
      'hover': 0.6,
      'form_interaction': 1.4,
      'button_click': 1.2,
      'link_click': 1.1,
      'form_submission': 1.6
    };
    
    score *= (interactionMultipliers[interactionData.type] || 1.0);
    
    // Calculate interaction weight based on user verification
    if (userValidation.phone_verified) weight += 0.3;
    if (userValidation.email_verified) weight += 0.3;
    if (userValidation.fraud_risk_level === 'low') weight += 0.4;
    
    // Calculate authenticity score
    if (userValidation.verification_status === 'verified') authenticityScore += 30;
    if (userValidation.fraud_risk_level === 'low') authenticityScore += 20;
    
    return {
      score: Math.min(100, score),
      weight: Math.min(2.0, weight),
      is_high_quality: score >= 70 && weight >= 1.3,
      reliability: this.calculateInteractionReliability(userValidation),
      authenticity_score: Math.min(100, authenticityScore),
      device_trust: this.calculateDeviceTrust(interactionData, userValidation),
      value_tier: this.determineInteractionValueTier(score, weight)
    };
  }
  
  determineHeatmapSegment(userValidation) {
    const qualityScore = userValidation.quality_score || 0;
    const verificationStatus = userValidation.verification_status || 'unverified';
    
    if (qualityScore >= 80 && verificationStatus === 'verified') {
      return 'premium_users';
    } else if (qualityScore >= 60) {
      return 'quality_users';
    } else if (qualityScore >= 40) {
      return 'standard_users';
    } else {
      return 'unverified_users';
    }
  }
  
  generateHeatmapTags(userValidation, interactionQuality) {
    const tags = [];
    
    // Quality tier tags
    tags.push(`quality-tier-${userValidation.tier || 'unknown'}`);
    
    // Verification status tags
    if (userValidation.phone_verified) tags.push('phone-verified');
    if (userValidation.email_verified) tags.push('email-verified');
    
    // Risk level tags
    const riskLevel = userValidation.fraud_risk_level || 'unknown';
    tags.push(`risk-${riskLevel}`);
    
    // Geographic tags
    if (userValidation.country) {
      tags.push(`country-${userValidation.country.toLowerCase()}`);
    }
    
    // Interaction quality tags
    if (interactionQuality.is_high_quality) {
      tags.push('high-quality-interaction');
    }
    
    tags.push(`interaction-value-${interactionQuality.value_tier}`);
    
    return tags;
  }
  
  async getUserValidationData(userId) {
    // This would typically fetch user data from your database
    // and validate their contact information
    try {
      const userData = await this.fetchUserData(userId);
      
      if (userData.phone || userData.email) {
        const validation = await this.validateUserContact({
          phone: userData.phone,
          email: userData.email
        });
        
        return {
          quality_score: this.calculateUserQualityScore(validation),
          tier: this.determineUserTier(validation),
          verification_status: this.getVerificationStatus(validation),
          phone_verified: validation.phone?.is_valid,
          email_verified: validation.email?.is_valid,
          fraud_risk_level: this.getFraudRiskLevel(validation),
          country: validation.phone?.location_details?.country,
          region: validation.phone?.location_details?.region,
          carrier_type: validation.phone?.carrier_details?.type
        };
      }
      
      return { quality_score: 0, tier: 'unverified' };
      
    } catch (error) {
      console.error('User validation data error:', error);
      return { quality_score: 0, tier: 'unknown', error: true };
    }
  }
}

// Advanced session replay enhancement with user validation context
class HotjarSessionEnhancer {
  constructor(hotjarId, lookupApiKey) {
    this.hotjarId = hotjarId;
    this.lookupApiKey = lookupApiKey;
    this.sessionValidationData = new Map();
  }
  
  async enhanceSessionWithUserValidation(sessionId, userId, sessionData) {
    try {
      // Get user validation data
      const userValidation = await this.getUserValidationForSession(userId);
      
      // Calculate session quality metrics
      const sessionQuality = this.calculateSessionQuality(sessionData, userValidation);
      
      // Enhanced session context
      const enhancedSessionContext = {
        session_id: sessionId,
        user_id: userId,
        // User validation context
        user_quality_score: userValidation.quality_score,
        user_verification_level: userValidation.verification_level,
        contact_validation_status: userValidation.contact_status,
        user_authenticity_score: userValidation.authenticity_score,
        // Session quality metrics
        session_quality_score: sessionQuality.overall_score,
        session_reliability: sessionQuality.reliability,
        session_value_tier: sessionQuality.value_tier,
        is_high_value_session: sessionQuality.is_high_value,
        // Behavioral insights
        interaction_authenticity: sessionQuality.interaction_authenticity,
        user_engagement_quality: sessionQuality.engagement_quality,
        session_fraud_indicators: sessionQuality.fraud_indicators,
        // Geographic and device context
        user_geographic_region: userValidation.region,
        device_trust_score: sessionQuality.device_trust,
        session_anomaly_score: sessionQuality.anomaly_score,
        // UX research context
        ux_research_segment: this.determineUXResearchSegment(userValidation),
        session_research_value: sessionQuality.research_value,
        behavioral_pattern_reliability: sessionQuality.pattern_reliability
      };
      
      // Apply session tags for better categorization
      const sessionTags = this.generateSessionTags(userValidation, sessionQuality);
      sessionTags.forEach(tag => {
        hj('tagRecording', [tag]);
      });
      
      // Track enhanced session analytics
      hj('event', 'enhanced_session_tracked', {
        session_quality: enhancedSessionContext.session_quality_score,
        user_tier: userValidation.tier,
        research_value: enhancedSessionContext.session_research_value
      });
      
      // Store enhanced session data
      this.sessionValidationData.set(sessionId, enhancedSessionContext);
      
      return enhancedSessionContext;
      
    } catch (error) {
      console.error('Session enhancement error:', error);
      
      // Track error but continue session recording
      hj('tagRecording', ['session-enhancement-error']);
      return {
        session_id: sessionId,
        enhancement_error: true,
        error_details: error.message
      };
    }
  }
  
  calculateSessionQuality(sessionData, userValidation) {
    let overallScore = 0;
    let reliability = 0;
    let interactionAuthenticity = 0;
    
    // Base score from user validation
    const userQuality = userValidation.quality_score || 0;
    overallScore = userQuality * 0.4; // 40% weight from user quality
    
    // Session behavioral indicators
    const sessionMetrics = this.analyzeSessionBehavior(sessionData);
    overallScore += sessionMetrics.behavior_score * 0.3; // 30% from behavior
    
    // User verification impact
    if (userValidation.phone_verified) overallScore += 15;
    if (userValidation.email_verified) overallScore += 15;
    
    // Calculate reliability score
    reliability = this.calculateSessionReliability(userValidation, sessionMetrics);
    
    // Calculate interaction authenticity
    interactionAuthenticity = this.calculateInteractionAuthenticity(
      sessionMetrics, 
      userValidation
    );
    
    // Determine session value tier
    const valueTier = this.determineSessionValueTier(overallScore, reliability);
    
    return {
      overall_score: Math.min(100, overallScore),
      reliability: Math.min(100, reliability),
      value_tier: valueTier,
      is_high_value: overallScore >= 70 && reliability >= 80,
      interaction_authenticity: Math.min(100, interactionAuthenticity),
      engagement_quality: sessionMetrics.engagement_score,
      fraud_indicators: this.detectSessionFraudIndicators(sessionMetrics, userValidation),
      device_trust: this.calculateDeviceTrustScore(sessionData, userValidation),
      anomaly_score: this.calculateSessionAnomalyScore(sessionMetrics),
      research_value: this.calculateResearchValue(overallScore, sessionMetrics),
      pattern_reliability: this.calculatePatternReliability(sessionMetrics, userValidation)
    };
  }
  
  analyzeSessionBehavior(sessionData) {
    const metrics = {
      behavior_score: 0,
      engagement_score: 0,
      interaction_count: sessionData.interactions?.length || 0,
      session_duration: sessionData.duration || 0,
      page_views: sessionData.page_views || 0,
      scroll_depth: sessionData.max_scroll_depth || 0
    };
    
    // Calculate behavior score based on session activity
    if (metrics.session_duration > 30) metrics.behavior_score += 20; // 30+ seconds
    if (metrics.session_duration > 120) metrics.behavior_score += 20; // 2+ minutes
    if (metrics.interaction_count > 3) metrics.behavior_score += 15; // Multiple interactions
    if (metrics.page_views > 1) metrics.behavior_score += 15; // Multiple pages
    if (metrics.scroll_depth > 50) metrics.behavior_score += 15; // Scrolled >50%
    
    // Calculate engagement score
    const engagementRate = (metrics.interaction_count / Math.max(1, metrics.session_duration)) * 60;
    if (engagementRate > 2) metrics.engagement_score += 30; // High engagement
    if (engagementRate > 1) metrics.engagement_score += 20; // Medium engagement
    if (engagementRate > 0.5) metrics.engagement_score += 10; // Low engagement
    
    return metrics;
  }
  
  determineUXResearchSegment(userValidation) {
    const qualityScore = userValidation.quality_score || 0;
    const verificationLevel = userValidation.verification_level || 'unverified';
    
    if (qualityScore >= 85 && verificationLevel === 'fully_verified') {
      return 'premium_research_users';
    } else if (qualityScore >= 70) {
      return 'high_value_research_users';
    } else if (qualityScore >= 50) {
      return 'standard_research_users';
    } else {
      return 'basic_research_users';
    }
  }
  
  generateSessionTags(userValidation, sessionQuality) {
    const tags = [];
    
    // User quality tags
    tags.push(`user-quality-${userValidation.tier || 'unknown'}`);
    
    // Session quality tags
    tags.push(`session-quality-${sessionQuality.value_tier}`);
    
    // Verification tags
    if (userValidation.phone_verified) tags.push('phone-verified-user');
    if (userValidation.email_verified) tags.push('email-verified-user');
    
    // Research segment tags
    tags.push(`research-segment-${this.determineUXResearchSegment(userValidation).replace(/_/g, '-')}`);
    
    // High-value session tag
    if (sessionQuality.is_high_value) tags.push('high-value-session');
    
    // Geographic tags
    if (userValidation.country) {
      tags.push(`country-${userValidation.country.toLowerCase()}`);
    }
    
    return tags;
  }
}