Best Slack Phone Validation API & Email Verification Integration 2025

# Quick validation commands
/validate-phone +1-555-123-4567
/validate-email john@example.com
/validate-contact +1-555-123-4567 john@example.com

# Batch validation
/validate-list @mention-file-with-contacts

# Team stats and usage
/lookup-stats team
/lookup-usage this-month
/lookup-help

# Example Slack response:
📞 Phone Validation Result for +1-555-123-4567
✅ Valid: Yes
📡 Carrier: Verizon Wireless  
📱 Type: Mobile
🌍 Country: United States
⚡ Response time: 127ms

// Scheduled report example
{
  "report_type": "weekly_summary",
  "channel": "#data-quality",
  "schedule": "Monday 9:00 AM",
  "content": {
    "title": "📊 Weekly Data Quality Report",
    "metrics": {
      "total_validations": 15420,
      "phone_success_rate": "94.2%",
      "email_success_rate": "91.8%",
      "fraud_alerts": 12,
      "top_issues": [
        "Invalid international numbers: 3.2%",
        "Disposable emails: 2.1%",
        "Carrier lookup failures: 1.8%"
      ]
    },
    "actions": [
      {
        "type": "button",
        "text": "View Full Report",
        "url": "https://dashboard.1lookup.com/reports/weekly"
      },
      {
        "type": "button", 
        "text": "Download CSV",
        "url": "https://dashboard.1lookup.com/export/csv"
      }
    ]
  }
}

// Advanced Slack Bolt app with 1lookup integration
const { App } = require('@slack/bolt');
const { createHash } = require('crypto');

const app = new App({
  token: process.env.SLACK_BOT_TOKEN,
  signingSecret: process.env.SLACK_SIGNING_SECRET,
  socketMode: true,
  appToken: process.env.SLACK_APP_TOKEN
});

// Interactive button responses
app.action('validate_contact_details', async ({ body, ack, client }) => {
  await ack();
  
  const contactData = JSON.parse(body.actions[0].value);
  
  // Validate with 1lookup API
  const results = await validateContactDetails(contactData);
  
  // Update message with results
  await client.chat.update({
    channel: body.channel.id,
    ts: body.message.ts,
    blocks: buildValidationResultBlocks(results)
  });
});

// Slash command with interactive elements
app.command('/validate-lead', async ({ command, ack, respond }) => {
  await ack();
  
  // Parse contact info from command text
  const parsed = parseContactInfo(command.text);
  
  if (!parsed.phone && !parsed.email) {
    await respond({
      response_type: 'ephemeral',
      blocks: [
        {
          type: 'section',
          text: {
            type: 'mrkdwn',
            text: 'Please provide phone and/or email. Example:\n`/validate-lead phone:+1234567890 email:john@example.com`'
          }
        }
      ]
    });
    return;
  }
  
  // Show loading state
  await respond({
    response_type: 'in_channel',
    blocks: [
      {
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: ':hourglass_flowing_sand: Validating contact details...'
        }
      }
    ]
  });
  
  try {
    // Validate contact
    const results = await Promise.all([
      parsed.phone ? validatePhone(parsed.phone) : null,
      parsed.email ? validateEmail(parsed.email) : null
    ]);
    
    // Build interactive response
    const blocks = buildInteractiveValidationBlocks(parsed, results);
    
    // Update with results
    await respond({
      response_type: 'in_channel',
      replace_original: true,
      blocks
    });
    
  } catch (error) {
    await respond({
      response_type: 'ephemeral',
      replace_original: true,
      text: `Error validating contact: ${error.message}`
    });
  }
});

// Home tab with validation dashboard
app.event('app_home_opened', async ({ event, client }) => {
  try {
    // Get user's recent validations
    const userStats = await getUserValidationStats(event.user);
    
    await client.views.publish({
      user_id: event.user,
      view: {
        type: 'home',
        blocks: [
          {
            type: 'header',
            text: {
              type: 'plain_text',
              text: '📞 1lookup Validation Dashboard'
            }
          },
          {
            type: 'section',
            fields: [
              {
                type: 'mrkdwn',
                text: `*Validations This Week:*\n${userStats.weekly_count}`
              },
              {
                type: 'mrkdwn',
                text: `*Success Rate:*\n${userStats.success_rate}%`
              }
            ]
          },
          {
            type: 'actions',
            elements: [
              {
                type: 'button',
                text: {
                  type: 'plain_text',
                  text: 'View Full Dashboard'
                },
                url: 'https://dashboard.1lookup.com',
                style: 'primary'
              },
              {
                type: 'button',
                text: {
                  type: 'plain_text',
                  text: 'Quick Validate'
                },
                action_id: 'open_validation_modal'
              }
            ]
          }
        ]
      }
    });
  } catch (error) {
    console.error('Error updating home tab:', error);
  }
});

// Modal for bulk validation
app.action('open_validation_modal', async ({ ack, body, client }) => {
  await ack();
  
  await client.views.open({
    trigger_id: body.trigger_id,
    view: {
      type: 'modal',
      callback_id: 'bulk_validation',
      title: {
        type: 'plain_text',
        text: 'Bulk Contact Validation'
      },
      submit: {
        type: 'plain_text',
        text: 'Validate'
      },
      blocks: [
        {
          type: 'input',
          block_id: 'contacts_input',
          element: {
            type: 'plain_text_input',
            action_id: 'contacts_text',
            multiline: true,
            placeholder: {
              type: 'plain_text',
              text: 'Enter contacts (one per line):\n+1234567890, john@example.com\n+1987654321, jane@example.com'
            }
          },
          label: {
            type: 'plain_text',
            text: 'Contact List'
          }
        }
      ]
    }
  });
});

// Secure webhook implementation
const crypto = require('crypto');
const express = require('express');

// Verify Slack request signature
function verifySlackSignature(req, res, next) {
  const slackSignature = req.headers['x-slack-signature'];
  const timestamp = req.headers['x-slack-request-timestamp'];
  const body = JSON.stringify(req.body);
  
  // Check timestamp to prevent replay attacks
  const time = Math.floor(new Date().getTime() / 1000);
  if (Math.abs(time - timestamp) > 300) {
    return res.status(400).send('Request too old');
  }
  
  // Verify signature
  const expectedSignature = 'v0=' + crypto
    .createHmac('sha256', process.env.SLACK_SIGNING_SECRET)
    .update(`v0:${timestamp}:${body}`)
    .digest('hex');
    
  if (crypto.timingSafeEqual(
    Buffer.from(expectedSignature),
    Buffer.from(slackSignature)
  )) {
    next();
  } else {
    res.status(401).send('Invalid signature');
  }
}

// Webhook endpoint for 1lookup notifications
app.post('/webhook/slack-alerts', verifySlackSignature, async (req, res) => {
  try {
    const alertData = req.body;
    
    // Route alert to appropriate channel
    const channel = getChannelForAlert(alertData.type);
    
    // Format message based on alert type
    const message = formatAlertMessage(alertData);
    
    // Send to Slack
    await sendSlackAlert(channel, message);
    
    res.status(200).json({ success: true });
    
  } catch (error) {
    console.error('Webhook error:', error);
    res.status(500).json({ error: 'Processing failed' });
  }
});

// Rate limiting for API endpoints
const rateLimit = require('express-rate-limit');
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 100,
  message: 'Too many requests'
});

app.use('/webhook', limiter);