Best Salesmate Phone Validation API & Email Verification Integration 2025

// Salesmate API integration with phone validation
const SalesmateClient = require('salesmate-api');
const fetch = require('node-fetch');

class SalesmateValidationIntegration {
  constructor(salesmateConfig, lookupApiKey) {
    this.salesmate = new SalesmateClient({
      sessionToken: salesmateConfig.sessionToken,
      domain: salesmateConfig.domain
    });
    this.lookupApiKey = lookupApiKey;
  }
  
  async createValidatedContact(contactData, pipelineId) {
    try {
      // Validate contact information first
      const validation = await this.validateContactInfo(contactData);
      
      // Calculate quality score for pipeline placement
      const qualityScore = this.calculateQualityScore(validation);
      
      // Create contact in Salesmate with validation data
      const contact = await this.salesmate.contact.create({
        name: contactData.name,
        email: validation.email?.isValid ? contactData.email : null,
        phone: validation.phone?.isValid ? contactData.phone : null,
        company: contactData.company,
        tags: this.generateValidationTags(validation),
        customField: {
          'phone_validation_status': validation.phone?.isValid ? 'Valid' : 'Invalid',
          'phone_carrier': validation.phone?.carrier || '',
          'phone_risk_level': validation.phone?.riskLevel || 'Unknown',
          'email_validation_status': validation.email?.isValid ? 'Valid' : 'Invalid',
          'validation_score': qualityScore,
          'validation_date': new Date().toISOString()
        }
      });
      
      // Create deal in appropriate pipeline stage
      const pipelineStage = this.determinePipelineStage(qualityScore, validation);
      
      const deal = await this.salesmate.deal.create({
        title: `Deal - ${contactData.name}`,
        contactId: contact.id,
        pipelineId: pipelineId,
        pipelineStageId: pipelineStage,
        value: this.estimateDealValue(qualityScore),
        customField: {
          'lead_quality_score': qualityScore,
          'contact_validation_summary': this.createValidationSummary(validation)
        }
      });
      
      // Schedule follow-up activities based on quality
      await this.scheduleFollowUpActivities(contact.id, deal.id, validation, qualityScore);
      
      return {
        success: true,
        contactId: contact.id,
        dealId: deal.id,
        qualityScore: qualityScore,
        validation: validation
      };
      
    } catch (error) {
      console.error('Salesmate contact creation failed:', error);
      return { success: false, error: error.message };
    }
  }
  
  async validateContactInfo(contactData) {
    const results = {};
    
    // Validate phone number
    if (contactData.phone) {
      const phoneResponse = await fetch('https://app.1lookup.io/api/v1/phone', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.lookupApiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ phone: contactData.phone })
      });
      
      if (phoneResponse.ok) {
        const phoneData = await phoneResponse.json();
        results.phone = {
          isValid: phoneData.data.classification.is_valid,
          carrier: phoneData.data.carrier_details?.name,
          lineType: phoneData.data.carrier_details?.type,
          riskLevel: phoneData.data.risk_assessment?.risk_level,
          location: phoneData.data.location_details?.city,
          country: phoneData.data.location_details?.country,
          timezone: phoneData.data.location_details?.timezone
        };
      }
    }
    
    // Validate email address
    if (contactData.email) {
      const emailResponse = await fetch('https://app.1lookup.io/api/v1/email', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.lookupApiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ email: contactData.email })
      });
      
      if (emailResponse.ok) {
        const emailData = await emailResponse.json();
        results.email = {
          isValid: emailData.data.classification.is_valid,
          deliverable: emailData.data.classification.deliverable,
          riskLevel: emailData.data.risk_assessment?.risk_level,
          domain: emailData.data.domain_details?.domain,
          domainAge: emailData.data.domain_details?.age_days
        };
      }
    }
    
    return results;
  }
  
  calculateQualityScore(validation) {
    let score = 0;
    
    // Phone validation scoring (60% weight)
    if (validation.phone) {
      if (validation.phone.isValid) {
        score += 35;
        
        // Risk level adjustments
        switch (validation.phone.riskLevel) {
          case 'Low': score += 20; break;
          case 'Medium': score += 10; break;
          case 'High': score -= 5; break;
        }
        
        // Line type bonus
        if (validation.phone.lineType === 'mobile') {
          score += 15; // Mobile phones typically better for sales
        } else if (validation.phone.lineType === 'landline') {
          score += 10; // Business landlines are also valuable
        }
        
        // Carrier reliability
        if (validation.phone.carrier && this.isReliableCarrier(validation.phone.carrier)) {
          score += 5;
        }
      } else {
        score -= 20; // Invalid phone significantly reduces quality
      }
    }
    
    // Email validation scoring (40% weight)
    if (validation.email) {
      if (validation.email.isValid) {
        score += 25;
        
        if (validation.email.deliverable) {
          score += 15;
        }
        
        // Risk level adjustments
        switch (validation.email.riskLevel) {
          case 'Low': score += 8; break;
          case 'Medium': score += 4; break;
          case 'High': score -= 3; break;
        }
        
        // Domain age bonus (older domains typically more reliable)
        if (validation.email.domainAge > 365) {
          score += 7;
        }
      } else {
        score -= 15;
      }
    }
    
    return Math.max(0, Math.min(100, score));
  }
  
  determinePipelineStage(qualityScore, validation) {
    // High quality leads go to qualified stage
    if (qualityScore >= 80) {
      return 'qualified_stage_id';
    }
    
    // Medium quality leads go to contacted stage
    if (qualityScore >= 60) {
      return 'contacted_stage_id';
    }
    
    // Lower quality leads start at prospecting
    if (qualityScore >= 35) {
      return 'prospecting_stage_id';
    }
    
    // Very low quality leads go to nurture stage
    return 'nurture_stage_id';
  }
  
  generateValidationTags(validation) {
    const tags = [];
    
    if (validation.phone?.isValid) {
      tags.push('phone-validated');
      
      if (validation.phone.riskLevel === 'Low') {
        tags.push('high-quality-phone');
      }
      
      if (validation.phone.lineType === 'mobile') {
        tags.push('mobile-contact');
      }
      
      tags.push(`carrier-${validation.phone.carrier?.toLowerCase().replace(/\s+/g, '-')}`);
    }
    
    if (validation.email?.isValid) {
      tags.push('email-validated');
      
      if (validation.email.deliverable) {
        tags.push('email-deliverable');
      }
    }
    
    return tags;
  }
  
  async scheduleFollowUpActivities(contactId, dealId, validation, qualityScore) {
    const activities = [];
    
    // High quality leads get immediate call activity
    if (qualityScore >= 80) {
      activities.push({
        type: 'call',
        contactId: contactId,
        dealId: dealId,
        dueDate: new Date(Date.now() + 1 * 60 * 60 * 1000), // 1 hour
        note: `High quality lead - Priority call. Quality Score: ${qualityScore}`,
        priority: 'high'
      });
    }
    
    // Medium quality leads get email follow-up
    else if (qualityScore >= 60) {
      activities.push({
        type: 'email',
        contactId: contactId,
        dealId: dealId,
        dueDate: new Date(Date.now() + 4 * 60 * 60 * 1000), // 4 hours
        note: `Send personalized email. Quality Score: ${qualityScore}`,
        priority: 'medium'
      });
    }
    
    // Lower quality leads get research task
    else {
      activities.push({
        type: 'task',
        contactId: contactId,
        dealId: dealId,
        dueDate: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours
        note: `Research and qualify lead further. Quality Score: ${qualityScore}`,
        priority: 'low'
      });
    }
    
    // Create all activities
    for (const activity of activities) {
      await this.salesmate.activity.create(activity);
    }
  }
  
  isReliableCarrier(carrier) {
    const reliableCarriers = ['Verizon', 'AT&T', 'T-Mobile', 'Sprint', 'US Cellular'];
    return reliableCarriers.includes(carrier);
  }
  
  estimateDealValue(qualityScore) {
    // Estimate deal value based on lead quality
    if (qualityScore >= 80) return 10000;
    if (qualityScore >= 60) return 5000;
    if (qualityScore >= 40) return 2500;
    return 1000;
  }
  
  createValidationSummary(validation) {
    const summary = [];
    
    if (validation.phone) {
      summary.push(`Phone: ${validation.phone.isValid ? 'Valid' : 'Invalid'}`);
      if (validation.phone.carrier) summary.push(`Carrier: ${validation.phone.carrier}`);
      if (validation.phone.location) summary.push(`Location: ${validation.phone.location}`);
    }
    
    if (validation.email) {
      summary.push(`Email: ${validation.email.isValid ? 'Valid' : 'Invalid'}`);
      if (validation.email.deliverable) summary.push('Email: Deliverable');
    }
    
    return summary.join(', ');
  }
}

// Usage example
const salesmateIntegration = new SalesmateValidationIntegration({
  sessionToken: process.env.SALESMATE_SESSION_TOKEN,
  domain: process.env.SALESMATE_DOMAIN
}, process.env.LOOKUP_API_KEY);

// Create a validated contact and deal
const result = await salesmateIntegration.createValidatedContact({
  name: 'John Doe',
  email: 'john@example.com',
  phone: '+1234567890',
  company: 'Acme Corp'
}, 'your_pipeline_id');

console.log('Contact creation result:', result);

// Advanced Salesmate pipeline automation with validation
class SalesmatePipelineAutomation {
  constructor(salesmateClient) {
    this.salesmate = salesmateClient;
    
    // Pipeline stage mapping
    this.stageMapping = {
      'prospecting': { minScore: 0, maxScore: 40, priority: 'low' },
      'contacted': { minScore: 40, maxScore: 60, priority: 'medium' },
      'qualified': { minScore: 60, maxScore: 80, priority: 'high' },
      'hot_lead': { minScore: 80, maxScore: 100, priority: 'urgent' }
    };
  }
  
  async automateDealsProgression(pipelineId) {
    try {
      const deals = await this.salesmate.deal.list({
        pipelineId: pipelineId,
        status: 'open'
      });
      
      const results = {
        processed: 0,
        moved: 0,
        activitiesCreated: 0,
        errors: []
      };
      
      for (const deal of deals) {
        try {
          // Get contact validation data
          const contact = await this.salesmate.contact.get(deal.contactId);
          const validationScore = contact.customField?.validation_score || 0;
          
          // Determine optimal stage
          const optimalStage = this.getOptimalStage(validationScore);
          const currentStage = deal.pipelineStageId;
          
          // Move deal if needed
          if (currentStage !== optimalStage.stageId) {
            await this.salesmate.deal.update(deal.id, {
              pipelineStageId: optimalStage.stageId,
              customField: {
                ...deal.customField,
                'stage_change_reason': 'Validation-based automation',
                'automation_date': new Date().toISOString(),
                'previous_stage': currentStage
              }
            });
            
            results.moved++;
          }
          
          // Create stage-appropriate activities
          const activities = await this.createStageActivities(deal, contact, optimalStage);
          results.activitiesCreated += activities.length;
          
          // Update deal priority and tags
          await this.updateDealMetadata(deal, validationScore, optimalStage);
          
          results.processed++;
          
        } catch (error) {
          results.errors.push(`Deal ${deal.id}: ${error.message}`);
        }
      }
      
      return results;
      
    } catch (error) {
      throw new Error(`Pipeline automation failed: ${error.message}`);
    }
  }
  
  getOptimalStage(validationScore) {
    for (const [stageName, criteria] of Object.entries(this.stageMapping)) {
      if (validationScore >= criteria.minScore && validationScore < criteria.maxScore) {
        return {
          name: stageName,
          stageId: this.getStageId(stageName),
          priority: criteria.priority,
          score: validationScore
        };
      }
    }
    
    // Fallback to prospecting
    return {
      name: 'prospecting',
      stageId: this.getStageId('prospecting'),
      priority: 'low',
      score: validationScore
    };
  }
  
  async createStageActivities(deal, contact, stageInfo) {
    const activities = [];
    const baseActivity = {
      dealId: deal.id,
      contactId: contact.id,
      assignedToId: deal.ownerId
    };
    
    switch (stageInfo.name) {
      case 'hot_lead':
        // Immediate call for hot leads
        activities.push(await this.salesmate.activity.create({
          ...baseActivity,
          type: 'call',
          subject: 'URGENT: Hot Lead Follow-up Call',
          dueDate: new Date(Date.now() + 30 * 60 * 1000), // 30 minutes
          priority: 'high',
          note: `Validation Score: ${stageInfo.score}/100 - High priority prospect`
        }));
        
        // Follow-up email
        activities.push(await this.salesmate.activity.create({
          ...baseActivity,
          type: 'email',
          subject: 'Hot Lead - Personalized Proposal',
          dueDate: new Date(Date.now() + 2 * 60 * 60 * 1000), // 2 hours
          priority: 'high',
          note: 'Send personalized proposal based on validation insights'
        }));
        break;
        
      case 'qualified':
        // Qualification call
        activities.push(await this.salesmate.activity.create({
          ...baseActivity,
          type: 'call',
          subject: 'Qualification & Needs Assessment Call',
          dueDate: new Date(Date.now() + 4 * 60 * 60 * 1000), // 4 hours
          priority: 'medium',
          note: `Quality Score: ${stageInfo.score}/100 - Qualified prospect`
        }));
        break;
        
      case 'contacted':
        // Email outreach
        activities.push(await this.salesmate.activity.create({
          ...baseActivity,
          type: 'email',
          subject: 'Initial Outreach Email',
          dueDate: new Date(Date.now() + 8 * 60 * 60 * 1000), // 8 hours
          priority: 'medium',
          note: 'Send initial value proposition email'
        }));
        break;
        
      case 'prospecting':
        // Research task
        activities.push(await this.salesmate.activity.create({
          ...baseActivity,
          type: 'task',
          subject: 'Prospect Research & Validation Review',
          dueDate: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours
          priority: 'low',
          note: `Score: ${stageInfo.score}/100 - Needs additional qualification`
        }));
        break;
    }
    
    return activities;
  }
  
  async updateDealMetadata(deal, validationScore, stageInfo) {
    const tags = [`score-${Math.floor(validationScore / 10) * 10}`, `priority-${stageInfo.priority}`];
    
    // Add validation-specific tags
    if (validationScore >= 80) tags.push('hot-prospect');
    else if (validationScore >= 60) tags.push('qualified-lead');
    else if (validationScore >= 40) tags.push('nurture-needed');
    else tags.push('research-required');
    
    await this.salesmate.deal.update(deal.id, {
      priority: stageInfo.priority,
      tags: tags,
      customField: {
        ...deal.customField,
        'validation_score': validationScore,
        'automation_stage': stageInfo.name,
        'last_automation_run': new Date().toISOString()
      }
    });
  }
  
  getStageId(stageName) {
    // Map stage names to actual Salesmate stage IDs
    const stageIds = {
      'prospecting': 'stage_prospecting_001',
      'contacted': 'stage_contacted_002', 
      'qualified': 'stage_qualified_003',
      'hot_lead': 'stage_hot_004'
    };
    
    return stageIds[stageName] || stageIds['prospecting'];
  }
  
  // Generate pipeline performance report
  async generatePerformanceReport(pipelineId, dateRange = 30) {
    const deals = await this.salesmate.deal.list({
      pipelineId: pipelineId,
      dateRange: dateRange
    });
    
    const report = {
      totalDeals: deals.length,
      stageDistribution: {},
      validationScoreDistribution: {},
      conversionRates: {},
      averageScoreByStage: {}
    };
    
    // Analyze deal distribution and performance
    deals.forEach(deal => {
      const score = deal.customField?.validation_score || 0;
      const stage = deal.customField?.automation_stage || 'unknown';
      
      // Stage distribution
      report.stageDistribution[stage] = (report.stageDistribution[stage] || 0) + 1;
      
      // Score distribution
      const scoreRange = `${Math.floor(score / 20) * 20}-${Math.floor(score / 20) * 20 + 19}`;
      report.validationScoreDistribution[scoreRange] = 
        (report.validationScoreDistribution[scoreRange] || 0) + 1;
      
      // Average score by stage
      if (!report.averageScoreByStage[stage]) {
        report.averageScoreByStage[stage] = { total: 0, count: 0 };
      }
      report.averageScoreByStage[stage].total += score;
      report.averageScoreByStage[stage].count += 1;
    });
    
    // Calculate averages
    Object.keys(report.averageScoreByStage).forEach(stage => {
      const data = report.averageScoreByStage[stage];
      report.averageScoreByStage[stage] = Math.round(data.total / data.count);
    });
    
    return report;
  }
}

// Usage example
const pipelineAutomation = new SalesmatePipelineAutomation(salesmateClient);

// Run automation
const automationResults = await pipelineAutomation.automateDealsProgression('pipeline_123');
console.log('Automation results:', automationResults);

// Generate performance report
const performanceReport = await pipelineAutomation.generatePerformanceReport('pipeline_123', 30);
console.log('Performance report:', performanceReport);