Best Notion Phone Validation API & Email Verification Integration 2025

// Advanced Notion Phone Validation Workflow (2025)
const { Client } = require('@notionhq/client');
const notion = new Client({ auth: process.env.NOTION_TOKEN });

class NotionValidationWorkflow {
  constructor(databaseId, apiKey) {
    this.databaseId = databaseId;
    this.apiKey = apiKey;
    this.validationEndpoint = 'https://api.1lookup.io/v1/phone';
  }

  async processContactDatabase() {
    // Query database for unvalidated contacts
    const response = await notion.databases.query({
      database_id: this.databaseId,
      filter: {
        or: [
          {
            property: 'Validation Status',
            select: { equals: 'Pending' }
          },
          {
            property: 'Phone Number',
            phone_number: { is_not_empty: true }
          }
        ]
      },
      sorts: [
        {
          property: 'Created',
          direction: 'descending'
        }
      ]
    });

    // Process contacts in batches
    const contacts = response.results;
    const batchSize = 10;
    
    for (let i = 0; i < contacts.length; i += batchSize) {
      const batch = contacts.slice(i, i + batchSize);
      await this.processBatch(batch);
      
      // Rate limiting
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }

  async processBatch(contacts) {
    const validationPromises = contacts.map(contact => 
      this.validateContact(contact)
    );
    
    const results = await Promise.allSettled(validationPromises);
    
    // Update Notion database with results
    for (let i = 0; i < results.length; i++) {
      const result = results[i];
      const contact = contacts[i];
      
      if (result.status === 'fulfilled') {
        await this.updateContactRecord(contact.id, result.value);
      } else {
        await this.logValidationError(contact.id, result.reason);
      }
    }
  }

  async validateContact(contact) {
    const phoneNumber = contact.properties['Phone Number']?.phone_number;
    const emailAddress = contact.properties['Email']?.email;
    
    if (!phoneNumber && !emailAddress) {
      return { status: 'no_data', message: 'No contact info provided' };
    }

    const validationData = {};
    
    // Phone validation with HLR lookup
    if (phoneNumber) {
      const phoneResponse = await fetch(this.validationEndpoint, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          phone: phoneNumber,
          options: { hlr: true, carrier: true, spam_check: true }
        })
      });
      
      validationData.phone = await phoneResponse.json();
    }

    // Email validation
    if (emailAddress) {
      const emailResponse = await fetch('https://api.1lookup.io/v1/email', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          email: emailAddress,
          options: { deliverability: true, risk_score: true }
        })
      });
      
      validationData.email = await emailResponse.json();
    }

    return this.processValidationResults(validationData);
  }

  async updateContactRecord(pageId, validationResults) {
    const updateData = {
      'Validation Status': {
        select: { name: validationResults.overallStatus }
      },
      'Phone Valid': {
        checkbox: validationResults.phoneValid || false
      },
      'Email Valid': {
        checkbox: validationResults.emailValid || false
      },
      'Carrier Info': {
        rich_text: [{
          text: { content: validationResults.carrierInfo || '' }
        }]
      },
      'Risk Score': {
        number: validationResults.riskScore || 0
      },
      'Last Validated': {
        date: { start: new Date().toISOString() }
      }
    };

    await notion.pages.update({
      page_id: pageId,
      properties: updateData
    });
  }

  processValidationResults(data) {
    const phoneValid = data.phone?.valid || false;
    const emailValid = data.email?.deliverable || false;
    
    let overallStatus = 'Invalid';
    if (phoneValid && emailValid) overallStatus = 'Verified';
    else if (phoneValid || emailValid) overallStatus = 'Partial';
    
    return {
      overallStatus,
      phoneValid,
      emailValid,
      carrierInfo: data.phone?.carrier || '',
      riskScore: Math.max(
        data.phone?.spam_score || 0,
        data.email?.risk_score || 0
      )
    };
  }
}

// Usage
const workflow = new NotionValidationWorkflow(
  process.env.NOTION_DATABASE_ID,
  process.env.LOOKUP_API_KEY
);

workflow.processContactDatabase()
  .then(() => console.log('Validation workflow completed'))
  .catch(error => console.error('Workflow error:', error));