Best JustCall Phone Validation API & International SMS Integration 2025

// JustCall API configuration
import axios from 'axios';

class JustCallClient {
  constructor(apiKey, apiSecret) {
    this.apiKey = apiKey;
    this.apiSecret = apiSecret;
    this.baseURL = 'https://api.justcall.io/v1';
    this.headers = {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
      'Accept': 'application/json'
    };
  }

  async makeCall(callData) {
    try {
      const response = await axios.post(`${this.baseURL}/calls/make`, callData, {
        headers: this.headers
      });
      return response.data;
    } catch (error) {
      console.error('JustCall API error:', error.response?.data || error.message);
      throw error;
    }
  }

  async sendSMS(smsData) {
    const response = await axios.post(`${this.baseURL}/sms/send`, smsData, {
      headers: this.headers
    });
    return response.data;
  }

  async getCallLogs(options = {}) {
    const params = new URLSearchParams({
      limit: options.limit || 100,
      offset: options.offset || 0,
      ...options.filters
    });

    const response = await axios.get(
      `${this.baseURL}/calls?${params}`,
      { headers: this.headers }
    );
    
    return response.data;
  }
}

const justCall = new JustCallClient(
  process.env.JUSTCALL_API_KEY,
  process.env.JUSTCALL_API_SECRET
);

// Test the connection
const accountInfo = await justCall.getAccountInfo();
console.log('Connected to JustCall account:', accountInfo.account.name);

// 1lookup configuration for JustCall international operations
import { OneLookupClient } from '@1lookup/sdk';

const oneLookup = new OneLookupClient({
  apiKey: process.env.ONELOOKUP_API_KEY,
  environment: 'production',
  timeout: 4000,
  retryAttempts: 3,
  internationalMode: true,
  globalOptimization: true,
  carrierIntelligence: true
});

// Configure international validation settings
const justCallInternationalConfig = {
  includeCarrierInfo: true,
  includeLocationInfo: true,
  includeInternationalRouting: true,
  includeCostOptimization: true,
  checkGlobalCompliance: true,
  enableSMSOptimization: true,
  supportedCountries: 'all', // or specific country codes
  validateForJustCall: true
};

// Test global validation capabilities
const globalTest = await oneLookup.international.healthCheck();
console.log('Global validation status:', globalTest.status);
console.log('Supported countries:', globalTest.supportedCountries.length);

// International call validation for JustCall
async function validateAndCallInternational(phoneNumber, fromNumber, countryCode) {
  try {
    // Validate international phone number
    const validation = await oneLookup.international.validatePhone({
      phone: phoneNumber,
      countryCode: countryCode,
      ...justCallInternationalConfig,
      context: {
        platform: 'justcall',
        callType: 'international',
        fromCountry: getCountryFromNumber(fromNumber)
      }
    });

    if (!validation.isValid) {
      console.log(`Invalid international number: ${phoneNumber}`);
      return { success: false, error: 'Invalid phone number format' };
    }

    // Check international routing compatibility
    if (!validation.internationalRouting.isSupported) {
      return { 
        success: false, 
        error: 'International routing not supported for this destination' 
      };
    }

    // Cost optimization check
    const costOptimization = await oneLookup.international.optimizeCost({
      destination: validation.e164Format,
      origin: fromNumber,
      carrier: validation.carrierInfo.name,
      preferredRoutes: ['premium', 'standard']
    });

    // Check compliance for destination country
    const complianceCheck = await oneLookup.compliance.checkInternational({
      phoneNumber: validation.e164Format,
      destinationCountry: validation.locationInfo.country,
      originCountry: getCountryFromNumber(fromNumber),
      callPurpose: 'business'
    });

    if (!complianceCheck.isCompliant) {
      return { 
        success: false, 
        error: `Compliance violation: ${complianceCheck.violations.join(', ')}`
      };
    }

    // Make the call through JustCall with optimizations
    const callResponse = await justCall.makeCall({
      from: fromNumber,
      to: validation.e164Format,
      webhook_url: process.env.JUSTCALL_WEBHOOK_URL,
      // Apply cost optimization
      routing_preference: costOptimization.recommendedRoute,
      max_call_cost: costOptimization.maxCostPerMinute,
      // Include validation metadata
      custom_data: {
        validation_id: validation.id,
        carrier: validation.carrierInfo.name,
        routing_score: validation.internationalRouting.qualityScore,
        compliance_status: 'verified'
      }
    });

    return {
      success: true,
      callId: callResponse.id,
      estimatedCost: costOptimization.estimatedCost,
      routingQuality: validation.internationalRouting.qualityScore,
      validationData: validation
    };

  } catch (error) {
    console.error('International call validation error:', error);
    return { success: false, error: error.message };
  }
}

// Bulk international validation for contact lists
async function bulkValidateInternational(contacts, targetCountry) {
  const validatedContacts = [];
  const invalidContacts = [];
  const processedCountries = new Set();

  for (const contact of contacts) {
    try {
      const validation = await oneLookup.international.validatePhone({
        phone: contact.phoneNumber,
        countryCode: contact.countryCode || targetCountry,
        includeCarrierInfo: true,
        includeLocationInfo: true,
        includeCostEstimate: true
      });

      if (validation.isValid) {
        validatedContacts.push({
          ...contact,
          validatedPhone: validation.e164Format,
          carrierInfo: validation.carrierInfo,
          locationInfo: validation.locationInfo,
          estimatedCallCost: validation.costEstimate,
          routingQuality: validation.routingQuality || 'unknown'
        });
        
        processedCountries.add(validation.locationInfo.country);
      } else {
        invalidContacts.push({
          ...contact,
          errors: validation.errors || ['Invalid phone number']
        });
      }
    } catch (error) {
      invalidContacts.push({
        ...contact,
        errors: [error.message]
      });
    }
  }

  // Generate summary statistics
  const summary = {
    totalProcessed: contacts.length,
    validContacts: validatedContacts.length,
    invalidContacts: invalidContacts.length,
    successRate: (validatedContacts.length / contacts.length * 100).toFixed(2),
    countriesProcessed: Array.from(processedCountries),
    estimatedTotalCost: validatedContacts.reduce((sum, c) => sum + (c.estimatedCallCost || 0), 0)
  };

  return {
    validatedContacts,
    invalidContacts,
    summary
  };
}

// Global SMS optimization for JustCall
async function optimizeGlobalSMS(phoneNumber, message, targetCountry, campaignType) {
  try {
    // Validate SMS deliverability internationally  
    const smsValidation = await oneLookup.sms.validateInternational({
      phone: phoneNumber,
      countryCode: targetCountry,
      message: message,
      includeCarrierOptimization: true,
      includeRegionalRules: true,
      includeDeliverabilityScore: true,
      checkGlobalCompliance: true,
      optimizeForJustCall: true
    });

    if (!smsValidation.canReceiveSMS) {
      return { 
        success: false, 
        error: `SMS not supported for ${phoneNumber} in ${targetCountry}` 
      };
    }

    // Check regional compliance
    if (!smsValidation.compliance.isCompliant) {
      return { 
        success: false, 
        error: `SMS compliance violation: ${smsValidation.compliance.violations.join(', ')}` 
      };
    }

    // Optimize message for target region
    const messageOptimization = await oneLookup.sms.optimizeForRegion({
      message: message,
      targetCountry: targetCountry,
      carrier: smsValidation.carrierInfo.name,
      language: smsValidation.regionInfo.primaryLanguage,
      campaignType: campaignType,
      preventSpamFilters: true,
      optimizeEncoding: true
    });

    // Calculate optimal sending time
    const optimalTiming = await oneLookup.sms.calculateOptimalTiming({
      targetCountry: targetCountry,
      timezone: smsValidation.regionInfo.timezone,
      campaignType: campaignType,
      carrierOptimization: true
    });

    // Send SMS through JustCall with optimizations
    const smsResponse = await justCall.sendSMS({
      from: getJustCallNumberForCountry(targetCountry),
      to: smsValidation.e164Format,
      body: messageOptimization.optimizedMessage,
      // Regional optimizations
      encoding: messageOptimization.encoding,
      delivery_receipt: true,
      optimal_send_time: optimalTiming.recommendedTime,
      // Tracking data
      custom_data: {
        validation_id: smsValidation.id,
        optimization_id: messageOptimization.id,
        deliverability_score: smsValidation.deliverabilityScore,
        target_country: targetCountry,
        carrier: smsValidation.carrierInfo.name
      }
    });

    return {
      success: true,
      messageId: smsResponse.id,
      deliverabilityScore: smsValidation.deliverabilityScore,
      optimizations: messageOptimization.appliedOptimizations,
      estimatedDeliveryTime: optimalTiming.estimatedDeliveryTime,
      cost: smsResponse.cost || messageOptimization.estimatedCost
    };

  } catch (error) {
    console.error('Global SMS optimization error:', error);
    return { success: false, error: error.message };
  }
}

// Multi-language SMS campaigns
async function sendMultiLanguageCampaign(campaignData) {
  const results = {};
  
  for (const [country, contacts] of Object.entries(campaignData.contactsByCountry)) {
    console.log(`Processing ${contacts.length} contacts for ${country}`);
    
    // Get localized message for country
    const localizedMessage = campaignData.messages[country] || campaignData.messages.default;
    
    // Process contacts in batches
    const batchSize = 100;
    const countryResults = [];
    
    for (let i = 0; i < contacts.length; i += batchSize) {
      const batch = contacts.slice(i, i + batchSize);
      
      const batchPromises = batch.map(contact => 
        optimizeGlobalSMS(
          contact.phoneNumber, 
          localizedMessage, 
          country, 
          campaignData.type
        )
      );
      
      const batchResults = await Promise.allSettled(batchPromises);
      countryResults.push(...batchResults);
      
      // Rate limiting for international SMS
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
    
    results[country] = {
      total: contacts.length,
      successful: countryResults.filter(r => r.status === 'fulfilled' && r.value.success).length,
      failed: countryResults.filter(r => r.status === 'rejected' || !r.value?.success).length,
      results: countryResults
    };
  }
  
  return results;
}

function getJustCallNumberForCountry(countryCode) {
  const countryNumbers = {
    'US': process.env.JUSTCALL_US_NUMBER,
    'CA': process.env.JUSTCALL_CA_NUMBER,
    'GB': process.env.JUSTCALL_UK_NUMBER,
    'AU': process.env.JUSTCALL_AU_NUMBER,
    'IN': process.env.JUSTCALL_IN_NUMBER,
    'default': process.env.JUSTCALL_DEFAULT_NUMBER
  };
  
  return countryNumbers[countryCode] || countryNumbers.default;
}