Best PhoneBurner Phone Validation API & Power Dialer Integration 2025

// Advanced campaign management for PhoneBurner
class PhoneBurnerCampaignManager {
  constructor(phoneBurnerClient, oneLookupClient) {
    this.phoneBurner = phoneBurnerClient;
    this.lookup = oneLookupClient;
  }

  async optimizeCampaign(campaignId, optimizationGoals) {
    const campaign = await this.phoneBurner.getCampaign(campaignId);
    const contacts = await this.phoneBurner.getCampaignContacts(campaignId);

    // Validate and score all contacts
    const optimizedContacts = await this.processContacts(contacts, optimizationGoals);
    
    // Create optimized calling schedule
    const schedule = await this.createOptimalSchedule(optimizedContacts);
    
    // Update PhoneBurner with optimizations
    await this.updateCampaignSettings(campaignId, {
      dialingOrder: schedule.dialingOrder,
      timingOptimization: schedule.timingRules,
      complianceSettings: schedule.complianceRules
    });

    return {
      totalContacts: contacts.length,
      validContacts: optimizedContacts.filter(c => c.isValid).length,
      expectedImprovement: this.calculateExpectedImprovement(optimizedContacts),
      schedule: schedule
    };
  }

  async processContacts(contacts, goals) {
    const processed = [];
    
    for (const contact of contacts) {
      try {
        const validation = await this.lookup.phone.validate({
          phone: contact.phoneNumber,
          includeCarrierInfo: true,
          includeLeadScoring: true,
          includeTiming: true,
          context: { goals: goals }
        });

        const leadScore = await this.calculateLeadScore(validation, contact, goals);
        const optimalTiming = await this.calculateOptimalTiming(validation, contact);

        processed.push({
          ...contact,
          validation: validation,
          leadScore: leadScore,
          optimalTiming: optimalTiming,
          isValid: validation.isValid,
          priority: this.calculatePriority(leadScore, goals)
        });

      } catch (error) {
        console.error(`Failed to process contact ${contact.id}:`, error);
        processed.push({
          ...contact,
          isValid: false,
          error: error.message,
          priority: 999 // Low priority
        });
      }
    }

    return processed;
  }

  async createOptimalSchedule(contacts) {
    // Group contacts by timezone and priority
    const timeZoneGroups = this.groupByTimezone(contacts);
    const schedule = {
      dialingOrder: [],
      timingRules: {},
      complianceRules: {}
    };

    // Create optimal dialing sequence
    for (const [timezone, groupContacts] of Object.entries(timeZoneGroups)) {
      // Sort by priority and optimal timing
      const sorted = groupContacts
        .filter(c => c.isValid)
        .sort((a, b) => {
          if (a.priority !== b.priority) return a.priority - b.priority;
          return this.compareOptimalTiming(a.optimalTiming, b.optimalTiming);
        });

      schedule.dialingOrder.push(...sorted.map(c => c.id));
      
      // Set timezone-specific timing rules
      schedule.timingRules[timezone] = {
        startHour: 9,
        endHour: 18,
        optimalHours: this.calculateOptimalHours(groupContacts)
      };
    }

    return schedule;
  }

  calculateLeadScore(validation, contact, goals) {
    let score = 50; // Base score

    // Validation quality
    if (validation.isValid) score += 20;
    if (validation.confidence > 90) score += 10;

    // Carrier quality
    if (validation.carrierInfo && validation.carrierInfo.reputation === 'high') {
      score += 15;
    }

    // Geographic targeting
    if (goals.targetRegions && validation.locationInfo) {
      if (goals.targetRegions.includes(validation.locationInfo.region)) {
        score += 20;
      }
    }

    // Historical performance
    if (contact.previousCalls && contact.previousCalls.length > 0) {
      const successRate = contact.previousCalls.filter(c => c.connected).length / contact.previousCalls.length;
      score += successRate * 25;
    }

    // Time-based scoring
    if (this.isOptimalTime(validation.optimalCallTime)) {
      score += 10;
    }

    return Math.max(0, Math.min(100, score));
  }

  groupByTimezone(contacts) {
    const groups = {};
    
    contacts.forEach(contact => {
      const timezone = contact.validation?.locationInfo?.timezone || 'unknown';
      if (!groups[timezone]) {
        groups[timezone] = [];
      }
      groups[timezone].push(contact);
    });

    return groups;
  }

  calculateOptimalHours(contacts) {
    // Analyze historical data to find optimal calling hours
    const hourlyPerformance = {};
    
    contacts.forEach(contact => {
      if (contact.previousCalls) {
        contact.previousCalls.forEach(call => {
          const hour = new Date(call.timestamp).getHours();
          if (!hourlyPerformance[hour]) {
            hourlyPerformance[hour] = { calls: 0, connected: 0 };
          }
          hourlyPerformance[hour].calls++;
          if (call.connected) hourlyPerformance[hour].connected++;
        });
      }
    });

    // Find hours with highest connection rates
    const hourlyRates = Object.entries(hourlyPerformance)
      .map(([hour, data]) => ({
        hour: parseInt(hour),
        rate: data.connected / data.calls
      }))
      .filter(h => h.rate > 0.3)
      .sort((a, b) => b.rate - a.rate)
      .slice(0, 4) // Top 4 hours
      .map(h => h.hour);

    return hourlyRates.length > 0 ? hourlyRates : [10, 11, 14, 15]; // Default optimal hours
  }
}