Best Expandi Phone Validation API & LinkedIn Automation Integration 2025

// Expandi webhook validation setup
const validateExpandiContacts = async (campaignData) => {
  const validatedContacts = [];
  
  for (const contact of campaignData.prospects) {
    try {
      // Validate contact for Expandi campaigns
      const validation = await fetch('https://app.1lookup.io/api/v1/expandi/validate', {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          linkedin_url: contact.linkedinUrl,
          phone: contact.phone,
          email: contact.email,
          campaign_type: 'connection_sequence',
          safety_level: 'maximum'
        })
      });
      
      const result = await validation.json();
      
      if (result.data.safety_score >= 80 && result.data.conversion_probability >= 0.7) {
        validatedContacts.push({
          ...contact,
          validation_score: result.data.overall_score,
          safety_rating: result.data.safety_score,
          sequence_recommendation: result.data.sequence_optimization,
          timing_suggestion: result.data.optimal_timing
        });
      }
      
      // Expandi-compliant delay
      await new Promise(resolve => setTimeout(resolve, 500));
      
    } catch (error) {
      console.error('Expandi validation error:', error);
    }
  }
  
  return validatedContacts;
};

// Expandi campaign optimization with validation
class ExpandiValidator {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://app.1lookup.io/api/v1';
    this.expandiSafetyThreshold = 80;
  }

  async optimizeExpandiCampaign(campaignId, prospects) {
    const optimizedCampaign = {
      high_priority: [],
      medium_priority: [],
      low_priority: [],
      excluded: []
    };

    for (const prospect of prospects) {
      const validation = await this.validateForExpandi(prospect);
      
      // Categorize based on validation results
      if (validation.safety_score >= 90 && validation.conversion_score >= 80) {
        optimizedCampaign.high_priority.push({
          ...prospect,
          validation: validation,
          sequence_type: 'aggressive'
        });
      } else if (validation.safety_score >= 80 && validation.conversion_score >= 60) {
        optimizedCampaign.medium_priority.push({
          ...prospect,
          validation: validation,
          sequence_type: 'standard'
        });
      } else if (validation.safety_score >= 70) {
        optimizedCampaign.low_priority.push({
          ...prospect,
          validation: validation,
          sequence_type: 'conservative'
        });
      } else {
        optimizedCampaign.excluded.push(prospect);
      }
      
      // Rate limiting for LinkedIn compliance
      await new Promise(resolve => setTimeout(resolve, 1000));
    }

    return optimizedCampaign;
  }

  async validateForExpandi(prospect) {
    const response = await fetch(`${this.baseUrl}/expandi/comprehensive`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        prospect: prospect,
        platform: 'expandi',
        analysis_depth: 'full'
      })
    });

    const result = await response.json();
    
    return {
      safety_score: result.data.linkedin_safety_score,
      conversion_score: result.data.conversion_probability * 100,
      profile_quality: result.data.profile_authenticity,
      contact_validity: result.data.contact_validation,
      sequence_recommendation: result.data.optimal_sequence
    };
  }
}

// Advanced sequence optimization for Expandi
const optimizeExpandiSequence = async (contacts) => {
  const sequenceStrategies = {
    executive_outreach: {
      steps: [
        { type: 'connection', delay: 0, message: 'executive_personalized' },
        { type: 'message', delay: 5, message: 'value_proposition' },
        { type: 'follow_up', delay: 10, message: 'gentle_reminder' }
      ],
      criteria: { seniority: 'executive', company_size: 'large' }
    },
    decision_maker: {
      steps: [
        { type: 'connection', delay: 0, message: 'decision_maker_focused' },
        { type: 'message', delay: 3, message: 'business_case' },
        { type: 'follow_up', delay: 7, message: 'roi_focused' }
      ],
      criteria: { role: 'decision_maker', validation_score: '>= 80' }
    },
    standard_prospect: {
      steps: [
        { type: 'connection', delay: 0, message: 'standard_personalized' },
        { type: 'message', delay: 4, message: 'solution_introduction' },
        { type: 'follow_up', delay: 8, message: 'case_study' }
      ],
      criteria: { validation_score: '>= 70' }
    }
  };

  const optimizedSequences = [];

  for (const contact of contacts) {
    const analysis = await analyzeContactForSequence(contact);
    const bestSequence = selectOptimalSequence(analysis, sequenceStrategies);
    
    optimizedSequences.push({
      contact: contact,
      sequence: bestSequence,
      timing: analysis.optimal_timing,
      personalization: analysis.personalization_data,
      safety_score: analysis.safety_assessment
    });
  }

  return optimizedSequences;
};

const analyzeContactForSequence = async (contact) => {
  const response = await fetch('https://app.1lookup.io/api/v1/sequence-analysis', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      linkedin_profile: contact.linkedinUrl,
      company: contact.company,
      role: contact.title,
      industry: contact.industry,
      connection_degree: contact.connectionDegree
    })
  });

  const result = await response.json();
  
  return {
    seniority_level: result.data.seniority_classification,
    decision_authority: result.data.decision_making_power,
    engagement_likelihood: result.data.response_probability,
    optimal_timing: result.data.best_contact_times,
    personalization_data: result.data.personalization_hooks,
    safety_assessment: result.data.outreach_safety_score
  };
};