Best Phantombuster Phone Validation API & Social Media Automation Integration 2025

// Phantombuster webhook validation setup
const validatePhantomData = async (extractedData) => {
  try {
    const validationResults = [];
    
    for (const contact of extractedData) {
      if (contact.phone || contact.email) {
        const validation = await fetch('https://app.1lookup.io/api/v1/validate', {
          method: 'POST',
          headers: {
            'Authorization': 'Bearer YOUR_API_KEY',
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            phone: contact.phone,
            email: contact.email,
            linkedin_url: contact.linkedinUrl,
            social_context: true
          })
        });
        
        const result = await validation.json();
        
        if (result.data.classification.is_valid) {
          validationResults.push({
            ...contact,
            validation: result.data,
            score: calculateLeadScore(result.data)
          });
        }
      }
      
      // Rate limiting for Phantombuster compliance
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
    
    return validationResults;
  } catch (error) {
    console.error('Validation error:', error);
    return [];
  }
};

// Direct Phantombuster API integration
class PhantombusterValidator {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://app.1lookup.io/api/v1';
  }

  async validateExtractedContacts(phantomResults) {
    const validatedContacts = [];
    
    for (const contact of phantomResults) {
      const validation = await this.validateContact(contact);
      
      if (validation.valid && validation.score >= 70) {
        validatedContacts.push({
          ...contact,
          enrichment: validation.enrichment,
          riskLevel: validation.riskLevel
        });
      }
    }
    
    return validatedContacts;
  }

  async validateContact(contact) {
    const requests = [];
    
    // Phone validation
    if (contact.phone) {
      requests.push(this.validatePhone(contact.phone));
    }
    
    // Email validation
    if (contact.email) {
      requests.push(this.validateEmail(contact.email));
    }
    
    // Profile validation
    if (contact.socialProfile) {
      requests.push(this.validateProfile(contact.socialProfile));
    }
    
    const results = await Promise.all(requests);
    return this.aggregateResults(results);
  }
}

// Multi-platform Phantombuster automation with validation
class PhantombusterMultiPlatform {
  constructor(config) {
    this.config = config;
    this.validator = new ContactValidator(config.apiKey);
    this.platforms = ['linkedin', 'instagram', 'twitter', 'facebook'];
  }

  async runMultiPlatformCampaign(campaignConfig) {
    const results = {
      totalContacts: 0,
      validatedContacts: 0,
      platformResults: {}
    };

    for (const platform of this.platforms) {
      try {
        console.log(`Running ${platform} automation...`);
        
        // Execute Phantombuster automation for platform
        const phantomResults = await this.runPhantomAutomation(
          platform, 
          campaignConfig[platform]
        );
        
        // Validate extracted contacts
        const validatedContacts = await this.validator.validateBatch(
          phantomResults,
          platform
        );
        
        // Store results
        results.platformResults[platform] = {
          extracted: phantomResults.length,
          validated: validatedContacts.length,
          contacts: validatedContacts
        };
        
        results.totalContacts += phantomResults.length;
        results.validatedContacts += validatedContacts.length;
        
        // Platform-specific delay
        await this.platformDelay(platform);
        
      } catch (error) {
        console.error(`${platform} automation failed:`, error);
      }
    }
    
    return results;
  }

  async runPhantomAutomation(platform, config) {
    const phantomApi = `https://api.phantombuster.com/api/v2/agents/${config.agentId}/launch`;
    
    const response = await fetch(phantomApi, {
      method: 'POST',
      headers: {
        'X-Phantombuster-Key': this.config.phantomApiKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        arguments: config.arguments,
        bonusArguments: {
          validation_webhook: 'https://your-webhook.com/validate',
          platform: platform
        }
      })
    });
    
    const launch = await response.json();
    
    // Wait for completion
    return await this.waitForCompletion(launch.containerId);
  }

  async waitForCompletion(containerId) {
    let status = 'running';
    let attempts = 0;
    const maxAttempts = 60; // 30 minutes max
    
    while (status === 'running' && attempts < maxAttempts) {
      await new Promise(resolve => setTimeout(resolve, 30000)); // 30 second intervals
      
      const statusResponse = await fetch(`https://api.phantombuster.com/api/v2/containers/${containerId}/output`, {
        headers: {
          'X-Phantombuster-Key': this.config.phantomApiKey
        }
      });
      
      const statusData = await statusResponse.json();
      status = statusData.status;
      attempts++;
    }
    
    return statusData.resultObject || [];
  }
}