// npm install node-fetch (or use built-in fetch in Node 18+)
const API_KEY = process.env.EMAILWIPES_API_KEY;

async function verifyEmail(email) {
  const response = await fetch('https://api.emails-wipes.com/v1/verify', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ email })
  });

  if (!response.ok) {
    const err = await response.json();
    throw new Error(`API error ${response.status}: ${err.message}`);
  }

  return response.json();
}

// Usage
const result = await verifyEmail('[email protected]');
console.log(result.status);     // "valid"
console.log(result.score);      // 0.98
console.log(result.sub_status); // null

// Block invalid and risky emails at signup
if (result.status === 'invalid' || result.is_disposable) {
  throw new Error('Please enter a valid business email address.');
}

// Middleware: validate email before processing signup
async function validateEmailMiddleware(req, res, next) {
  const { email } = req.body;

  if (!email) return res.status(400).json({ error: 'Email is required' });

  try {
    const result = await verifyEmail(email);

    if (result.status === 'invalid') {
      return res.status(422).json({
        error: 'Invalid email address',
        field: 'email'
      });
    }

    if (result.is_disposable) {
      return res.status(422).json({
        error: 'Disposable email addresses are not allowed',
        field: 'email'
      });
    }

    // Attach result to request for downstream use
    req.emailValidation = result;
    next();
  } catch (err) {
    // On API error, allow through (fail open) — log for review
    console.error('Email validation failed:', err.message);
    next();
  }
}

// Apply to signup route
app.post('/signup', validateEmailMiddleware, signupHandler);

import os
import requests

API_KEY = os.environ["EMAILWIPES_API_KEY"]
BASE_URL = "https://api.emails-wipes.com/v1"

def verify_email(email: str) -> dict:
    """Verify a single email address. Returns validation result dict."""
    response = requests.post(
        f"{BASE_URL}/verify",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={"email": email},
        timeout=10  # Always set a timeout in production
    )
    response.raise_for_status()
    return response.json()

def is_safe_to_send(email: str) -> bool:
    """Returns True if the email is valid and safe to send to."""
    try:
        result = verify_email(email)
        return (
            result["status"] == "valid"
            and not result["is_disposable"]
            and not result["is_role_based"]
            and result["score"] > 0.7
        )
    except requests.RequestException as e:
        print(f"Validation API error: {e}")
        return True  # Fail open — don't block signups on API outage

# Django / Flask form validation example
from django.core.exceptions import ValidationError

def validate_email_field(value):
    result = verify_email(value)
    if result["status"] == "invalid":
        raise ValidationError("This email address appears to be invalid.")
    if result["is_disposable"]:
        raise ValidationError("Please use a permanent email address.")

<?php
class EmailWipesClient {
    private string $apiKey;
    private string $baseUrl = 'https://api.emails-wipes.com/v1';

    public function __construct(string $apiKey) {
        $this->apiKey = $apiKey;
    }

    public function verify(string $email): array {
        $ch = curl_init("{$this->baseUrl}/verify");

        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_POST           => true,
            CURLOPT_POSTFIELDS     => json_encode(['email' => $email]),
            CURLOPT_TIMEOUT        => 10,
            CURLOPT_HTTPHEADER     => [
                'Authorization: Bearer ' . $this->apiKey,
                'Content-Type: application/json',
                'Accept: application/json'
            ]
        ]);

        $response = curl_exec($ch);
        $httpCode  = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode !== 200) {
            throw new RuntimeException("API returned HTTP {$httpCode}");
        }

        return json_decode($response, true);
    }

    public function isSafeToSend(string $email): bool {
        try {
            $result = $this->verify($email);
            return $result['status'] === 'valid'
                && !$result['is_disposable']
                && $result['score'] > 0.7;
        } catch (RuntimeException $e) {
            error_log("Email validation error: " . $e->getMessage());
            return true; // Fail open on API errors
        }
    }
}

// Usage
$client = new EmailWipesClient($_ENV['EMAILWIPES_API_KEY']);
$result = $client->verify('[email protected]');

if ($result['status'] === 'invalid') {
    // Return validation error to form
    $errors['email'] = 'Please enter a valid email address.';
}

{
  "event": "bulk_job.completed",
  "job_id": "job_abc123",
  "total": 15000,
  "valid": 12480,
  "invalid": 1830,
  "risky": 690,
  "download_url": "https://api.emails-wipes.com/v1/bulk/job_abc123/results",
  "created_at": "2026-02-19T14:32:00Z",
  "completed_at": "2026-02-19T14:34:12Z"
}

import crypto from 'crypto';

function verifyWebhookSignature(rawBody, signature, secret) {
  const expected = crypto
    .createHmac('sha256', secret)
    .update(rawBody)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(expected),
    Buffer.from(signature)
  );
}

// Express webhook handler
app.post('/webhooks/emailwipes', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.headers['x-emailwipes-signature'];

  if (!verifyWebhookSignature(req.body, sig, process.env.WEBHOOK_SECRET)) {
    return res.status(401).send('Invalid signature');
  }

  const event = JSON.parse(req.body);

  if (event.event === 'bulk_job.completed') {
    // Trigger your downstream processing
    processValidationResults(event.job_id, event.download_url);
  }

  res.sendStatus(200); // Acknowledge immediately
});

// Exponential backoff with jitter
async function verifyWithRetry(email, maxRetries = 3) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await verifyEmail(email);
    } catch (err) {
      const isRetryable = err.status === 429 || err.status >= 500;

      if (!isRetryable || attempt === maxRetries) {
        // Fail open: log and return a "pass" result
        console.error(`Validation failed after ${attempt} retries:`, err);
        return { status: 'unknown', score: 0.5, _failedOpen: true };
      }

      // Exponential backoff: 100ms, 200ms, 400ms + random jitter
      const delay = Math.pow(2, attempt) * 100 + Math.random() * 50;
      await new Promise(r => setTimeout(r, delay));
    }
  }
}