Best Pipedrive Phone Validation API & Email Verification Integration 2025

// Node.js Pipedrive + 1lookup Integration
const axios = require('axios');

class PipedriveValidator {
  constructor(pipedriveToken, lookupApiKey) {
    this.pipedriveToken = pipedriveToken;
    this.lookupApiKey = lookupApiKey;
    this.pipedriveBase = 'https://api.pipedrive.com/v1';
    this.lookupBase = 'https://api.1lookup.com/v1';
  }

  // Validate all contacts in a specific pipeline
  async validatePipelineContacts(pipelineId) {
    try {
      // Get all deals in pipeline
      const dealsResponse = await axios.get(
        `${this.pipedriveBase}/deals`,
        {
          params: {
            api_token: this.pipedriveToken,
            pipeline_id: pipelineId,
            status: 'open'
          }
        }
      );

      const deals = dealsResponse.data.data || [];
      const results = [];

      // Process each deal
      for (const deal of deals) {
        if (deal.person_id) {
          const validationResult = await this.validateDealContact(deal);
          results.push(validationResult);
          
          // Add delay to respect rate limits
          await this.delay(500);
        }
      }

      return results;
    } catch (error) {
      console.error('Pipeline validation error:', error);
      throw error;
    }
  }

  // Validate contact for a specific deal
  async validateDealContact(deal) {
    try {
      // Get person details
      const personResponse = await axios.get(
        `${this.pipedriveBase}/persons/${deal.person_id}`,
        {
          params: { api_token: this.pipedriveToken }
        }
      );

      const person = personResponse.data.data;
      const phone = person.phone?.[0]?.value;
      const email = person.email?.[0]?.value;

      if (!phone && !email) {
        return { deal_id: deal.id, status: 'no_contact_info' };
      }

      // Validate with 1lookup
      const validationPromises = [];
      
      if (phone) {
        validationPromises.push(this.validatePhone(phone));
      }
      
      if (email) {
        validationPromises.push(this.validateEmail(email));
      }

      const [phoneResult, emailResult] = await Promise.all(validationPromises);

      // Calculate lead score
      const leadScore = this.calculateLeadScore(phoneResult, emailResult);

      // Update Pipedrive with results
      await this.updatePipedriveContact(person.id, deal.id, {
        phoneResult,
        emailResult,
        leadScore
      });

      return {
        deal_id: deal.id,
        person_id: person.id,
        phone_result: phoneResult,
        email_result: emailResult,
        lead_score: leadScore,
        status: 'validated'
      };

    } catch (error) {
      console.error(`Deal validation error for deal ${deal.id}:`, error);
      return { deal_id: deal.id, status: 'error', error: error.message };
    }
  }

  // Validate phone number
  async validatePhone(phone) {
    try {
      const response = await axios.post(
        `${this.lookupBase}/phone`,
        { phone },
        {
          headers: {
            'Authorization': `Bearer ${this.lookupApiKey}`,
            'Content-Type': 'application/json'
          }
        }
      );

      return response.data;
    } catch (error) {
      console.error('Phone validation error:', error);
      return { valid: false, error: error.message };
    }
  }

  // Validate email address
  async validateEmail(email) {
    try {
      const response = await axios.post(
        `${this.lookupBase}/email`,
        { email },
        {
          headers: {
            'Authorization': `Bearer ${this.lookupApiKey}`,
            'Content-Type': 'application/json'
          }
        }
      );

      return response.data;
    } catch (error) {
      console.error('Email validation error:', error);
      return { valid: false, error: error.message };
    }
  }

  // Calculate lead score based on validation results
  calculateLeadScore(phoneResult, emailResult) {
    let score = 0;

    // Phone validation scoring
    if (phoneResult?.valid) {
      score += 40;
      if (phoneResult.line_type === 'Mobile') score += 10;
      if (phoneResult.carrier_name && !phoneResult.carrier_name.includes('VOIP')) score += 10;
    }

    // Email validation scoring
    if (emailResult?.valid) {
      score += 40;
      if (emailResult.quality_score) {
        score += Math.round(emailResult.quality_score * 0.2); // Max 20 points
      }
      if (!emailResult.is_disposable) score += 5;
      if (!emailResult.is_role_account) score += 5;
    }

    return Math.min(score, 100);
  }

  // Update Pipedrive contact with validation results
  async updatePipedriveContact(personId, dealId, validationData) {
    try {
      const { phoneResult, emailResult, leadScore } = validationData;

      // Prepare custom field updates
      const personUpdates = {};
      const dealUpdates = {};

      // Phone validation field
      if (phoneResult) {
        if (phoneResult.valid) {
          personUpdates['phone_validation'] = `✓ Valid (${phoneResult.carrier_name || 'Unknown'})`;
        } else {
          personUpdates['phone_validation'] = '✗ Invalid';
        }
      }

      // Email validation field
      if (emailResult) {
        if (emailResult.valid) {
          personUpdates['email_validation'] = `✓ Valid (Quality: ${emailResult.quality_score || 'N/A'}/100)`;
        } else {
          personUpdates['email_validation'] = '✗ Invalid';
        }
      }

      // Lead score
      personUpdates['lead_score'] = leadScore;
      
      // Contact quality
      if (leadScore >= 80) {
        personUpdates['contact_quality'] = 'High Quality';
        dealUpdates['stage_id'] = 'qualified_lead_stage_id'; // Replace with actual stage ID
      } else if (leadScore >= 50) {
        personUpdates['contact_quality'] = 'Medium Quality';
      } else {
        personUpdates['contact_quality'] = 'Low Quality';
        dealUpdates['stage_id'] = 'needs_review_stage_id'; // Replace with actual stage ID
      }

      // Update person
      if (Object.keys(personUpdates).length > 0) {
        await axios.put(
          `${this.pipedriveBase}/persons/${personId}`,
          personUpdates,
          {
            params: { api_token: this.pipedriveToken }
          }
        );
      }

      // Update deal if needed
      if (Object.keys(dealUpdates).length > 0) {
        await axios.put(
          `${this.pipedriveBase}/deals/${dealId}`,
          dealUpdates,
          {
            params: { api_token: this.pipedriveToken }
          }
        );
      }

    } catch (error) {
      console.error('Pipedrive update error:', error);
      throw error;
    }
  }

  // Utility delay function
  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Usage example
const validator = new PipedriveValidator(
  'your_pipedrive_api_token',
  'your_1lookup_api_key'
);

// Validate all contacts in a specific pipeline
validator.validatePipelineContacts('pipeline_id_here')
  .then(results => {
    console.log('Validation completed:', results);
  })
  .catch(error => {
    console.error('Validation failed:', error);
  });