Best Typeform Phone Validation API & Email Verification Integration 2025

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

class TypeformValidator {
  constructor(typeformToken, lookupApiKey) {
    this.typeformToken = typeformToken;
    this.lookupApiKey = lookupApiKey;
    this.typeformBase = 'https://api.typeform.com';
    this.lookupBase = 'https://api.1lookup.com/v1';
  }

  // Process and validate form responses
  async processFormResponses(formId, options = {}) {
    try {
      console.log(`Processing responses for form: ${formId}`);
      
      // Get form responses
      const responses = await this.getFormResponses(formId, options);
      console.log(`Found ${responses.length} responses to validate`);
      
      const results = {
        total: responses.length,
        validated: 0,
        high_quality: 0,
        medium_quality: 0,
        low_quality: 0,
        invalid: 0
      };

      // Process each response
      for (const response of responses) {
        const validationResult = await this.validateResponse(response);
        
        // Update response with validation data
        await this.updateResponseData(formId, response.token, validationResult);
        
        // Update statistics
        results.validated++;
        if (validationResult.quality_level === 'high') results.high_quality++;
        else if (validationResult.quality_level === 'medium') results.medium_quality++;
        else if (validationResult.quality_level === 'low') results.low_quality++;
        else results.invalid++;
        
        // Rate limiting
        await this.delay(200);
      }

      console.log('Form response validation completed:', results);
      return results;
      
    } catch (error) {
      console.error('Form validation error:', error);
      throw error;
    }
  }

  // Get responses from Typeform
  async getFormResponses(formId, options = {}) {
    try {
      const params = {
        page_size: 100,
        ...options
      };

      const response = await axios.get(
        `${this.typeformBase}/forms/${formId}/responses`,
        {
          headers: {
            'Authorization': `Bearer ${this.typeformToken}`
          },
          params
        }
      );

      return response.data.items || [];
    } catch (error) {
      console.error('Error fetching form responses:', error);
      throw error;
    }
  }

  // Validate individual form response
  async validateResponse(response) {
    try {
      const answers = response.answers || [];
      
      // Extract email and phone from answers
      const emailAnswer = answers.find(a => a.type === 'email');
      const phoneAnswer = answers.find(a => a.type === 'phone_number');
      
      const email = emailAnswer?.email;
      const phone = phoneAnswer?.phone_number;
      
      if (!email && !phone) {
        return {
          quality_level: 'invalid',
          response_score: 0,
          validation_error: 'No email or phone provided'
        };
      }

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

      const [emailResult, phoneResult] = await Promise.all(validationPromises);
      
      // Calculate response quality
      const responseScore = this.calculateResponseScore(emailResult, phoneResult);
      const qualityLevel = this.getQualityLevel(responseScore);
      
      return {
        email_result: emailResult,
        phone_result: phoneResult,
        response_score: responseScore,
        quality_level: qualityLevel,
        validation_date: new Date().toISOString(),
        tags: this.generateTags(responseScore, emailResult, phoneResult)
      };
      
    } catch (error) {
      console.error(`Response validation error for ${response.token}:`, error);
      return {
        quality_level: 'error',
        response_score: 0,
        validation_error: error.message
      };
    }
  }

  // Validate email with 1lookup
  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 };
    }
  }

  // Validate phone with 1lookup
  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 };
    }
  }

  // Calculate response quality score
  calculateResponseScore(emailResult, phoneResult) {
    let score = 0;

    // Email scoring (0-60 points)
    if (emailResult?.valid) {
      score += 30;
      if (emailResult.quality_score) {
        score += Math.round(emailResult.quality_score * 0.3);
      }
      if (!emailResult.is_disposable) score += 5;
      if (!emailResult.is_role_account) score += 5;
    }

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

    return Math.min(score, 100);
  }

  // Determine quality level from score
  getQualityLevel(score) {
    if (score >= 85) return 'high';
    if (score >= 60) return 'medium';
    if (score >= 30) return 'low';
    return 'invalid';
  }

  // Generate tags based on validation results
  generateTags(score, emailResult, phoneResult) {
    const tags = [];
    
    // Quality tags
    if (score >= 85) tags.push('high-quality', 'verified-response');
    else if (score >= 60) tags.push('medium-quality');
    else if (score >= 30) tags.push('low-quality');
    else tags.push('invalid-response');
    
    // Specific validation tags
    if (emailResult?.valid) tags.push('valid-email');
    if (phoneResult?.valid) tags.push('valid-phone');
    if (phoneResult?.line_type === 'Mobile') tags.push('mobile-number');
    if (emailResult?.is_disposable) tags.push('disposable-email');
    
    return tags;
  }

  // Update response with validation metadata
  async updateResponseData(formId, responseToken, validationResult) {
    try {
      // Store validation results in external database or system
      // Typeform doesn't allow updating submitted responses directly
      
      const validationRecord = {
        form_id: formId,
        response_token: responseToken,
        validation_date: validationResult.validation_date,
        response_score: validationResult.response_score,
        quality_level: validationResult.quality_level,
        email_valid: validationResult.email_result?.valid || false,
        phone_valid: validationResult.phone_result?.valid || false,
        tags: validationResult.tags
      };
      
      // Store in your database or send to another system
      console.log('Validation record:', validationRecord);
      
      // Optional: Send to webhook endpoint or external system
      // await this.sendToExternalSystem(validationRecord);
      
    } catch (error) {
      console.error(`Error updating response data for ${responseToken}:`, error);
    }
  }

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

// Usage example
const validator = new TypeformValidator(
  'your_typeform_token',
  'your_1lookup_api_key'
);

// Process all responses for a form
validator.processFormResponses('form_id_here')
  .then(results => {
    console.log('Form validation completed:', results);
  })
  .catch(error => {
    console.error('Form validation failed:', error);
  });