Vérification Email Node.js : Tutoriel API

La création d'applications qui collectent des adresses email nécessite une vérification d'email robuste pour maintenir la qualité des données et protéger votre réputation d'expéditeur. Les développeurs Node.js disposent d'outils puissants pour intégrer des services de vérification d'email dans leurs applications. Ce tutoriel complet vous guide à travers l'implémentation de l'intégration d'une API de vérification d'email avec Node.js, de la configuration de base aux implémentations prêtes pour la production.

Pourquoi Node.js pour l'intégration de la vérification d'email

Node.js est devenu le runtime privilégié pour la création d'applications web modernes, et sa nature asynchrone le rend particulièrement adapté aux intégrations d'API comme la vérification d'email. Lorsque les utilisateurs soumettent des adresses email via vos formulaires, vous avez besoin d'une vérification rapide et non bloquante qui ne ralentit pas l'expérience utilisateur. Node.js excelle dans la gestion efficace de multiples requêtes API concurrentes, ce qui le rend idéal pour les scénarios de vérification d'email unique en temps réel et de traitement par lot.

L'écosystème npm fournit d'excellentes bibliothèques de clients HTTP qui simplifient l'intégration d'API. Que vous préfériez l'API fetch intégrée, axios ou node-fetch, l'implémentation d'un validateur d'email dans Node.js nécessite un minimum de code passe-partout tout en offrant une flexibilité maximale pour la personnalisation.

Configuration de votre projet Node.js

Avant de plonger dans l'implémentation de la vérification d'email, assurez-vous que votre environnement de développement est correctement configuré. Vous aurez besoin de Node.js version 18 ou supérieure pour profiter de l'API fetch native, bien que les versions antérieures puissent utiliser node-fetch comme polyfill.

Installation des dépendances

Créez un nouveau répertoire de projet et initialisez-le avec npm. Votre package.json doit inclure les dépendances nécessaires pour les requêtes HTTP et la gestion des variables d'environnement. Le package dotenv aide à sécuriser vos identifiants API en les chargeant à partir de fichiers d'environnement plutôt que de coder en dur des informations sensibles dans votre code source.

// package.json
{
  "name": "email-verification-demo",
  "version": "1.0.0",
  "type": "module",
  "dependencies": {
    "dotenv": "^16.3.1"
  }
}

Configuration des variables d'environnement

Stockez votre clé API BillionVerify dans un fichier d'environnement. Ne committez jamais les clés API dans le contrôle de version. Le fichier .env garde les identifiants séparés de votre base de code, suivant les meilleures pratiques de sécurité recommandées par tous les services de vérification d'email.

# .env
BILLIONVERIFY_API_KEY=your_api_key_here

Implémentation de la vérification d'email unique

La base de toute intégration de vérification d'email est la capacité à vérifier des adresses email individuelles. Cette fonctionnalité alimente la validation en temps réel lors de l'inscription des utilisateurs, des soumissions de formulaires de contact et de tout scénario où un retour immédiat est requis.

Effectuer votre premier appel API

L'API de vérification d'email BillionVerify accepte des requêtes POST avec l'adresse email dans le corps de la requête. La réponse inclut des résultats de vérification complets incluant l'état de validité, l'évaluation de la délivrabilité et des vérifications détaillées pour les emails jetables, les adresses basées sur des rôles et les domaines catch-all.

// verify-email.js
import 'dotenv/config';

const API_BASE_URL = 'https://api.billionverify.com/v1';
const API_KEY = process.env.BILLIONVERIFY_API_KEY;

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

  if (!response.ok) {
    throw new Error(`Verification failed: ${response.status}`);
  }

  return response.json();
}

// Usage example
const result = await verifyEmail('user@example.com');
console.log(result);

Comprendre les champs de réponse

La réponse de vérification fournit des informations exploitables sur chaque adresse email. Comprendre ces champs de réponse vous aide à prendre des décisions éclairées sur l'acceptation ou non d'une adresse email dans votre système.

Construction d'une classe de validateur d'email réutilisable

Les applications de production bénéficient de l'encapsulation de la logique de vérification d'email dans une classe réutilisable. Cette approche fournit une gestion cohérente des erreurs, des tentatives automatiques et une interface claire pour le reste de votre application.

Architecture de la classe

La classe EmailValidator abstrait les détails HTTP et fournit des méthodes pour les scénarios de vérification courants. Elle gère l'authentification API, le formatage des requêtes et l'analyse des réponses, permettant à votre code applicatif de se concentrer sur la logique métier plutôt que sur la mécanique de l'API.

// EmailValidator.js
import 'dotenv/config';

class EmailValidator {
  constructor(apiKey = process.env.BILLIONVERIFY_API_KEY) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.billionverify.com/v1';
    this.maxRetries = 3;
    this.retryDelay = 1000;
  }

  async verify(email) {
    let lastError;

    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
      try {
        const response = await fetch(`${this.baseUrl}/verify`, {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${this.apiKey}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({ email })
        });

        if (response.status === 429) {
          // Rate limited - wait and retry
          await this.sleep(this.retryDelay * attempt);
          continue;
        }

        if (!response.ok) {
          throw new Error(`API error: ${response.status}`);
        }

        return await response.json();
      } catch (error) {
        lastError = error;
        if (attempt < this.maxRetries) {
          await this.sleep(this.retryDelay * attempt);
        }
      }
    }

    throw lastError;
  }

  async isValid(email) {
    const result = await this.verify(email);
    return result.is_valid && result.is_deliverable;
  }

  async isHighRisk(email) {
    const result = await this.verify(email);
    return result.risk_score > 70 || result.is_disposable;
  }

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

export default EmailValidator;

Logique de réessai automatique

Cette classe implémente un backoff exponentiel pour les requêtes échouées, ce qui est essentiel pour la fiabilité en production. Lorsque le service de vérification d'email renvoie une erreur de limitation de débit ou rencontre des problèmes temporaires, la classe réessaie automatiquement avec des délais croissants entre les tentatives.

Intégration avec les applications Express.js

La plupart des applications web Node.js utilisent Express.js ou des frameworks similaires. L'intégration de la vérification d'email dans vos routes Express permet une validation en temps réel lors des soumissions de formulaires. Les utilisateurs reçoivent un retour immédiat sur les adresses email invalides, améliorant l'expérience d'inscription tout en protégeant la qualité de votre liste d'emails.

Création d'un middleware de vérification

Créez une fonction middleware qui valide les adresses email avant qu'elles n'atteignent vos gestionnaires de routes. Cette approche sépare la logique de vérification de la logique métier, rendant votre code plus maintenable et testable.

// server.js
import express from 'express';
import EmailValidator from './EmailValidator.js';

const app = express();
const validator = new EmailValidator();

app.use(express.json());

// Middleware for email verification
const verifyEmailMiddleware = async (req, res, next) => {
  const { email } = req.body;

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

  try {
    const result = await validator.verify(email);

    if (!result.is_valid) {
      return res.status(400).json({
        error: 'Invalid email address',
        details: result
      });
    }

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

    // Attach verification result for downstream use
    req.emailVerification = result;
    next();
  } catch (error) {
    console.error('Email verification failed:', error);
    // Allow request to proceed but flag as unverified
    req.emailVerification = { verified: false, error: error.message };
    next();
  }
};

// Registration endpoint with email verification
app.post('/api/register', verifyEmailMiddleware, async (req, res) => {
  const { email, name, password } = req.body;

  // Email is already verified by middleware
  // Proceed with registration logic

  res.json({
    success: true,
    message: 'Registration successful',
    emailVerification: req.emailVerification
  });
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

Gestion des résultats de vérification

L'approche middleware offre une flexibilité dans la rigueur avec laquelle vous appliquez la vérification d'email. Certaines applications peuvent choisir de rejeter tous les emails non vérifiés, tandis que d'autres pourraient les accepter avec un indicateur d'avertissement pour un examen manuel. Les résultats de la validation d'adresse email attachés à l'objet de requête permettent aux gestionnaires en aval de prendre des décisions nuancées.

Vérification d'email par lot pour le nettoyage de listes

Alors que la vérification en temps réel gère les adresses individuelles, de nombreuses applications doivent vérifier de grandes listes d'emails. Les équipes marketing nettoient régulièrement leurs listes d'abonnés, et les systèmes CRM valident périodiquement les contacts stockés. Le point de terminaison de vérification par lot traite plusieurs emails efficacement, réduisant les appels API et améliorant le débit.

Soumission des travaux par lots

Les opérations par lot nécessitent une gestion différente des vérifications uniques. Vous devrez gérer la soumission de travaux, l'interrogation de l'état et la récupération des résultats comme des opérations séparées. Ce modèle asynchrone permet au service de vérification d'email de traiter de grandes listes sans délai d'expiration.

// batch-verify.js
import EmailValidator from './EmailValidator.js';

class BatchEmailValidator extends EmailValidator {
  async submitBatch(emails) {
    const response = await fetch(`${this.baseUrl}/verify/batch`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ emails })
    });

    if (!response.ok) {
      throw new Error(`Batch submission failed: ${response.status}`);
    }

    return response.json();
  }

  async getBatchStatus(jobId) {
    const response = await fetch(`${this.baseUrl}/verify/batch/${jobId}`, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`
      }
    });

    if (!response.ok) {
      throw new Error(`Status check failed: ${response.status}`);
    }

    return response.json();
  }

  async verifyBatch(emails, options = {}) {
    const {
      pollInterval = 5000,
      maxWaitTime = 300000,
      onProgress = () => {}
    } = options;

    // Submit the batch job
    const { job_id } = await this.submitBatch(emails);

    const startTime = Date.now();

    // Poll for completion
    while (Date.now() - startTime < maxWaitTime) {
      const status = await this.getBatchStatus(job_id);

      onProgress({
        processed: status.processed,
        total: status.total,
        percentage: Math.round((status.processed / status.total) * 100)
      });

      if (status.status === 'completed') {
        return status.results;
      }

      if (status.status === 'failed') {
        throw new Error(`Batch job failed: ${status.error}`);
      }

      await this.sleep(pollInterval);
    }

    throw new Error('Batch verification timed out');
  }
}

// Usage example
const batchValidator = new BatchEmailValidator();

const emails = [
  'user1@example.com',
  'user2@company.org',
  'invalid@fake.domain',
  // ... more emails
];

const results = await batchValidator.verifyBatch(emails, {
  onProgress: (progress) => {
    console.log(`Progress: ${progress.percentage}%`);
  }
});

// Process results
const validEmails = results.filter(r => r.is_valid);
const invalidEmails = results.filter(r => !r.is_valid);

console.log(`Valid: ${validEmails.length}, Invalid: ${invalidEmails.length}`);

Interrogation des résultats

L'implémentation de la vérification par lot inclut un callback de progression, permettant à votre application d'afficher la progression de la vérification aux utilisateurs ou de la journaliser pour la surveillance. Cela est particulièrement utile lors du traitement de listes avec des milliers d'adresses email qui peuvent prendre plusieurs minutes à compléter.

Gestion des erreurs et résilience

Les intégrations de vérification d'email en production doivent gérer les erreurs avec élégance. Les problèmes de réseau, les limitations de débit API et l'indisponibilité du service sont inévitables dans les systèmes distribués. La mise en œuvre d'une gestion appropriée des erreurs garantit que votre application reste fonctionnelle même lorsque le service de vérification rencontre des problèmes.

Classes d'erreurs personnalisées

Créez une stratégie complète de gestion des erreurs qui distingue les différents types d'erreurs. Les erreurs transitoires comme les limitations de débit méritent des tentatives de nouvelle requête, tandis que les erreurs permanentes comme les clés API invalides nécessitent une attention immédiate et des alertes.

// errors.js
class EmailVerificationError extends Error {
  constructor(message, code, retryable = false) {
    super(message);
    this.name = 'EmailVerificationError';
    this.code = code;
    this.retryable = retryable;
  }
}

class RateLimitError extends EmailVerificationError {
  constructor(retryAfter) {
    super('Rate limit exceeded', 'RATE_LIMITED', true);
    this.retryAfter = retryAfter;
  }
}

class AuthenticationError extends EmailVerificationError {
  constructor() {
    super('Invalid API key', 'AUTH_FAILED', false);
  }
}

// Enhanced validator with error handling
class RobustEmailValidator extends EmailValidator {
  async verify(email) {
    try {
      const response = await fetch(`${this.baseUrl}/verify`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ email })
      });

      if (response.status === 401) {
        throw new AuthenticationError();
      }

      if (response.status === 429) {
        const retryAfter = response.headers.get('Retry-After') || 60;
        throw new RateLimitError(parseInt(retryAfter));
      }

      if (response.status >= 500) {
        throw new EmailVerificationError(
          'Service temporarily unavailable',
          'SERVICE_ERROR',
          true
        );
      }

      if (!response.ok) {
        const error = await response.json();
        throw new EmailVerificationError(
          error.message || 'Verification failed',
          'API_ERROR',
          false
        );
      }

      return response.json();
    } catch (error) {
      if (error instanceof EmailVerificationError) {
        throw error;
      }

      // Network or parsing error
      throw new EmailVerificationError(
        error.message,
        'NETWORK_ERROR',
        true
      );
    }
  }
}

export { EmailVerificationError, RateLimitError, AuthenticationError, RobustEmailValidator };

Implémentation d'une dégradation gracieuse

Votre code applicatif peut ensuite gérer différents types d'erreurs de manière appropriée, fournissant des retours significatifs aux utilisateurs et déclenchant des alertes appropriées pour les équipes d'exploitation.

Implémentation de la mise en cache pour les performances

Les appels à l'API de vérification d'email ont un coût, tant en termes d'argent que de latence. La mise en œuvre d'une couche de mise en cache réduit les vérifications redondantes pour les mêmes adresses email tout en améliorant les temps de réponse. Un cache bien conçu respecte la nature dynamique de la validité des emails tout en offrant des avantages de performance significatifs.

Stratégie de cache en mémoire

Choisissez une durée de cache appropriée en fonction de votre cas d'usage. La validité des emails peut changer - les boîtes aux lettres sont supprimées, les domaines expirent, les configurations catch-all changent. Une durée de cache de 24 heures équilibre performance et précision pour la plupart des applications.

// cached-validator.js
class CachedEmailValidator extends EmailValidator {
  constructor(apiKey, cacheOptions = {}) {
    super(apiKey);
    this.cache = new Map();
    this.cacheTTL = cacheOptions.ttl || 24 * 60 * 60 * 1000; // 24 hours
    this.maxCacheSize = cacheOptions.maxSize || 10000;
  }

  getCacheKey(email) {
    return email.toLowerCase().trim();
  }

  getCached(email) {
    const key = this.getCacheKey(email);
    const cached = this.cache.get(key);

    if (!cached) return null;

    if (Date.now() > cached.expiresAt) {
      this.cache.delete(key);
      return null;
    }

    return cached.result;
  }

  setCache(email, result) {
    // Implement LRU eviction if cache is full
    if (this.cache.size >= this.maxCacheSize) {
      const oldestKey = this.cache.keys().next().value;
      this.cache.delete(oldestKey);
    }

    const key = this.getCacheKey(email);
    this.cache.set(key, {
      result,
      expiresAt: Date.now() + this.cacheTTL
    });
  }

  async verify(email) {
    // Check cache first
    const cached = this.getCached(email);
    if (cached) {
      return { ...cached, fromCache: true };
    }

    // Perform verification
    const result = await super.verify(email);

    // Cache successful results
    if (result && !result.error) {
      this.setCache(email, result);
    }

    return { ...result, fromCache: false };
  }

  clearCache() {
    this.cache.clear();
  }

  getCacheStats() {
    return {
      size: this.cache.size,
      maxSize: this.maxCacheSize
    };
  }
}

export default CachedEmailValidator;

Invalidation du cache

Pour les applications de production gérant des volumes élevés, envisagez d'utiliser Redis ou Memcached au lieu d'un cache en mémoire. Ces magasins de cache externes persistent au-delà des redémarrages de l'application et peuvent être partagés entre plusieurs instances d'application dans un déploiement en cluster.

Test de votre intégration de vérification d'email

Des tests complets garantissent que votre intégration de vérification d'email fonctionne correctement dans tous les scénarios. Les tests unitaires vérifient les composants individuels, tandis que les tests d'intégration confirment la communication appropriée avec l'API. Simulez la couche HTTP pendant les tests unitaires pour éviter de faire de vrais appels API.

Tests unitaires avec mocks

// validator.test.js
import { jest } from '@jest/globals';
import EmailValidator from './EmailValidator.js';

describe('EmailValidator', () => {
  let validator;

  beforeEach(() => {
    validator = new EmailValidator('test-api-key');
    global.fetch = jest.fn();
  });

  test('returns valid result for valid email', async () => {
    fetch.mockResolvedValueOnce({
      ok: true,
      json: () => Promise.resolve({
        is_valid: true,
        is_deliverable: true,
        is_disposable: false,
        risk_score: 10
      })
    });

    const result = await validator.verify('valid@example.com');

    expect(result.is_valid).toBe(true);
    expect(result.is_deliverable).toBe(true);
  });

  test('handles rate limiting with retry', async () => {
    fetch
      .mockResolvedValueOnce({ ok: false, status: 429 })
      .mockResolvedValueOnce({
        ok: true,
        json: () => Promise.resolve({ is_valid: true })
      });

    const result = await validator.verify('test@example.com');

    expect(fetch).toHaveBeenCalledTimes(2);
    expect(result.is_valid).toBe(true);
  });

  test('throws after max retries exceeded', async () => {
    fetch.mockResolvedValue({ ok: false, status: 500 });

    await expect(validator.verify('test@example.com'))
      .rejects.toThrow('API error: 500');
  });
});

Test des cas limites

Incluez des tests pour les cas limites comme les échecs de réseau, les réponses mal formées et les formats d'email inhabituels. Le vérificateur d'email doit gérer tous les scénarios avec élégance sans faire planter votre application.

Meilleures pratiques de surveillance et de journalisation

Les intégrations de vérification d'email en production nécessitent une surveillance pour suivre les performances, identifier les problèmes et optimiser les coûts. Implémentez une journalisation structurée qui capture les résultats de vérification, les temps de réponse et les taux d'erreur.

Logging structuré

// monitored-validator.js
class MonitoredEmailValidator extends EmailValidator {
  constructor(apiKey, logger = console) {
    super(apiKey);
    this.logger = logger;
    this.metrics = {
      totalRequests: 0,
      successfulVerifications: 0,
      failedVerifications: 0,
      cacheHits: 0,
      totalLatency: 0
    };
  }

  async verify(email) {
    const startTime = Date.now();
    this.metrics.totalRequests++;

    try {
      const result = await super.verify(email);
      const latency = Date.now() - startTime;

      this.metrics.successfulVerifications++;
      this.metrics.totalLatency += latency;

      this.logger.info({
        event: 'email_verification',
        email: this.maskEmail(email),
        is_valid: result.is_valid,
        latency_ms: latency
      });

      return result;
    } catch (error) {
      this.metrics.failedVerifications++;

      this.logger.error({
        event: 'email_verification_error',
        email: this.maskEmail(email),
        error: error.message,
        latency_ms: Date.now() - startTime
      });

      throw error;
    }
  }

  maskEmail(email) {
    const [local, domain] = email.split('@');
    const maskedLocal = local.charAt(0) + '***' + local.slice(-1);
    return `${maskedLocal}@${domain}`;
  }

  getMetrics() {
    return {
      ...this.metrics,
      averageLatency: this.metrics.totalRequests > 0
        ? Math.round(this.metrics.totalLatency / this.metrics.totalRequests)
        : 0,
      successRate: this.metrics.totalRequests > 0
        ? (this.metrics.successfulVerifications / this.metrics.totalRequests * 100).toFixed(2)
        : 0
    };
  }
}

export default MonitoredEmailValidator;

Suivi des métriques

Configurez des alertes pour les taux d'erreur élevés ou les modèles inhabituels qui pourraient indiquer des problèmes d'API ou des tentatives d'abus. Les tableaux de bord de surveillance vous aident à comprendre les modèles de vérification et à optimiser votre implémentation au fil du temps.

Considérations de sécurité

Les intégrations de vérification d'email gèrent des données potentiellement sensibles et nécessitent une attention particulière à la sécurité. Protégez vos clés API, validez les entrées et implémentez une limitation de débit sur vos propres points de terminaison pour prévenir les abus.

Protection des identifiants API

N'exposez jamais votre clé API BillionVerify au code côté client. Toutes les requêtes de vérification doivent passer par votre serveur backend, qui détient les identifiants API en toute sécurité. Cela empêche les acteurs malveillants d'utiliser votre quota API à leurs propres fins.

Validation des entrées et limitation de débit

Implémentez une validation des entrées avant d'envoyer des emails à l'API de vérification. Une validation de format de base de votre côté réduit les appels API inutiles et fournit un retour plus rapide pour les entrées manifestement invalides.

// secure-validator.js
class SecureEmailValidator extends EmailValidator {
  constructor(apiKey, options = {}) {
    super(apiKey);
    this.rateLimiter = new Map();
    this.maxRequestsPerMinute = options.maxRequestsPerMinute || 100;
  }

  validateEmailFormat(email) {
    if (!email || typeof email !== 'string') {
      throw new Error('Email must be a non-empty string');
    }

    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!emailRegex.test(email)) {
      throw new Error('Invalid email format');
    }

    if (email.length > 254) {
      throw new Error('Email exceeds maximum length');
    }

    return email.toLowerCase().trim();
  }

  checkRateLimit(clientId) {
    const now = Date.now();
    const windowStart = now - 60000;

    if (!this.rateLimiter.has(clientId)) {
      this.rateLimiter.set(clientId, []);
    }

    const requests = this.rateLimiter.get(clientId);
    const recentRequests = requests.filter(time => time > windowStart);

    if (recentRequests.length >= this.maxRequestsPerMinute) {
      throw new Error('Rate limit exceeded. Please try again later.');
    }

    recentRequests.push(now);
    this.rateLimiter.set(clientId, recentRequests);
  }

  async verify(email, clientId = 'default') {
    this.checkRateLimit(clientId);
    const sanitizedEmail = this.validateEmailFormat(email);
    return super.verify(sanitizedEmail);
  }
}

export default SecureEmailValidator;

Conclusion

L'implémentation de la vérification d'email dans les applications Node.js fournit la base pour maintenir des listes d'emails de haute qualité et protéger votre réputation d'expéditeur. Les techniques couvertes dans ce tutoriel - de l'intégration API de base aux modèles prêts pour la production incluant la mise en cache, la gestion des erreurs et la surveillance - vous équipent pour construire une validation d'email robuste dans n'importe quelle application Node.js.

L'API de vérification d'email de BillionVerify s'intègre parfaitement avec Node.js, offrant une vérification d'email unique en temps réel et des capacités de traitement par lot. Les données de réponse permettent une prise de décision nuancée concernant l'acceptation des emails, des simples déterminations valide/invalide au filtrage sophistiqué basé sur les risques.

Commencez avec l'implémentation de base pour comprendre les modèles d'API, puis ajoutez progressivement la mise en cache, la surveillance et la gestion des erreurs au fur et à mesure que les exigences de votre application évoluent. Les modèles de vérificateur d'email démontrés ici s'adaptent des MVP de startups aux applications de niveau entreprise traitant des millions de vérifications.

Que vous construisiez un système d'inscription d'utilisateurs, nettoyiez des listes marketing ou validiez des soumissions de formulaires de contact, une vérification d'email appropriée protège votre délivrabilité email et garantit que vos messages atteignent de vrais destinataires. Faites le premier pas en vous inscrivant pour un compte BillionVerify et en intégrant la vérification d'email dans votre application Node.js dès aujourd'hui.