E-Mail-Verifizierung API mit Node.js: Tutorial

Die Grundlage jeder E-Mail-Verifizierungsintegration ist die Fähigkeit, einzelne E-Mail-Adressen zu überprüfen. Diese Funktionalität ermöglicht die Validierung in Echtzeit während der Benutzerregistrierung, bei Kontaktformular-Übermittlungen und in jedem Szenario, in dem sofortiges Feedback erforderlich ist.

Durchführung Ihres ersten API-Aufrufs

Die BillionVerify E-Mail-Verifizierung API akzeptiert POST-Anfragen mit der E-Mail-Adresse im Anfrage-Body. Die Antwort enthält umfassende Verifizierungsergebnisse, einschließlich Gültigkeitsstatus, Zustellbarkeitsbewertung und detaillierter Prüfungen auf Wegwerf-E-Mails, rollenbasierte Adressen und Catch-All-Domains.

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

const API_BASE_URL = 'https://api.billionverify.com/v1';
const API_KEY = process.env.BV_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);

Verständnis der Antwortfelder

Die Verifizierungsantwort liefert verwertbare Informationen über jede E-Mail-Adresse. Das Verständnis dieser Antwortfelder hilft Ihnen, fundierte Entscheidungen darüber zu treffen, ob Sie eine E-Mail-Adresse in Ihr System aufnehmen möchten.

Erstellen einer wiederverwendbaren E-Mail-Validator-Klasse

Produktionsanwendungen profitieren von der Kapselung der E-Mail-Verifizierungslogik in einer wiederverwendbaren Klasse. Dieser Ansatz bietet konsistente Fehlerbehandlung, automatische Wiederholungsversuche und eine saubere Schnittstelle für den Rest Ihrer Anwendung.

Klassenarchitektur

Die EmailValidator-Klasse abstrahiert die HTTP-Details und bietet Methoden für gängige Verifizierungsszenarien. Sie verwaltet API-Authentifizierung, Anfrage-Formatierung und Antwort-Parsing, sodass sich Ihr Anwendungscode auf die Geschäftslogik konzentrieren kann, anstatt auf API-Mechanismen.

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

class EmailValidator {
  constructor(apiKey = process.env.BV_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;

Automatische Wiederholungslogik

Diese Klasse implementiert exponentielles Backoff für fehlgeschlagene Anfragen, was für die Zuverlässigkeit in der Produktion unerlässlich ist. Wenn der E-Mail-Verifizierungsdienst einen Ratenlimit-Fehler zurückgibt oder vorübergehende Probleme auftreten, versucht die Klasse automatisch erneut mit zunehmenden Verzögerungen zwischen den Versuchen.

Integration mit Express.js-Anwendungen

Die meisten Node.js-Webanwendungen verwenden Express.js oder ähnliche Frameworks. Die Integration der E-Mail-Verifizierung in Ihre Express-Routen ermöglicht die Validierung in Echtzeit während der Formularübermittlung. Benutzer erhalten sofortiges Feedback über ungültige E-Mail-Adressen, was die Registrierungserfahrung verbessert und gleichzeitig die Qualität Ihrer E-Mail-Liste schützt.

Erstellung von Verifizierungs-Middleware

Erstellen Sie eine Middleware-Funktion, die E-Mail-Adressen validiert, bevor sie Ihre Route-Handler erreichen. Dieser Ansatz trennt Verifizierungslogik von Geschäftslogik und macht Ihren Code wartbarer und testbarer.

// 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');
});

Behandlung von Verifizierungsergebnissen

Der Middleware-Ansatz bietet Flexibilität darin, wie streng Sie die E-Mail-Verifizierung durchsetzen. Einige Anwendungen entscheiden sich möglicherweise dafür, alle nicht verifizierten E-Mails abzulehnen, während andere sie mit einer Warnflagge für manuelle Überprüfung akzeptieren. Die an das Request-Objekt angehängten E-Mail-Validierungsergebnisse ermöglichen es nachgelagerten Handlern, nuancierte Entscheidungen zu treffen.

Batch-E-Mail-Verifizierung für Listenbereinigung

Während die Echtzeit-Verifizierung einzelne Adressen verarbeitet, müssen viele Anwendungen große E-Mail-Listen verifizieren. Marketingteams bereinigen regelmäßig ihre Abonnentenlisten, und CRM-Systeme validieren periodisch gespeicherte Kontakte. Der Batch-Verifizierungs-Endpoint verarbeitet mehrere E-Mails effizient und reduziert API-Aufrufe und verbessert den Durchsatz.

Einreichen von Batch-Jobs

Batch-Operationen erfordern eine andere Handhabung als Einzelverifizierungen. Sie müssen Job-Einreichung, Statusabfrage und Ergebnisabruf als separate Operationen verwalten. Dieses asynchrone Muster ermöglicht es dem E-Mail-Verifizierungsdienst, große Listen zu verarbeiten, ohne dass ein Timeout auftritt.

// 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}`);

Abfrage der Ergebnisse

Die Batch-Verifizierungsimplementierung enthält einen Fortschritts-Callback, der es Ihrer Anwendung ermöglicht, den Verifizierungsfortschritt Benutzern anzuzeigen oder für die Überwachung zu protokollieren. Dies ist besonders nützlich bei der Verarbeitung von Listen mit Tausenden von E-Mail-Adressen, deren Fertigstellung mehrere Minuten dauern kann.

Fehlerbehandlung und Resilienz

Produktionsreife E-Mail-Verifizierungsintegrationen müssen Fehler elegant behandeln. Netzwerkprobleme, API-Ratenlimits und Dienstunverfügbarkeit sind in verteilten Systemen unvermeidlich. Die Implementierung ordnungsgemäßer Fehlerbehandlung stellt sicher, dass Ihre Anwendung funktionsfähig bleibt, auch wenn der Verifizierungsdienst Probleme hat.

Benutzerdefinierte Fehlerklassen

Erstellen Sie eine umfassende Fehlerbehandlungsstrategie, die zwischen verschiedenen Fehlertypen unterscheidet. Transiente Fehler wie Ratenlimits verdienen Wiederholungsversuche, während permanente Fehler wie ungültige API-Schlüssel sofortige Aufmerksamkeit und Alarmierung erfordern.

// 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 };

Implementierung von graceful Degradation

Ihr Anwendungscode kann dann verschiedene Fehlertypen angemessen behandeln, Benutzern aussagekräftiges Feedback geben und geeignete Alarme für Operations-Teams auslösen.

Implementierung von Caching für Performance

E-Mail-Verifizierung API-Aufrufe haben Kosten, sowohl in Bezug auf Geld als auch auf Latenz. Die Implementierung einer Caching-Schicht reduziert redundante Verifizierungen für dieselben E-Mail-Adressen und verbessert gleichzeitig die Antwortzeiten. Ein gut konzipierter Cache respektiert die dynamische Natur der E-Mail-Gültigkeit und bietet gleichzeitig bedeutende Leistungsvorteile.

In-Memory-Cache-Strategie

Wählen Sie eine angemessene Cache-Dauer basierend auf Ihrem Anwendungsfall. Die E-Mail-Gültigkeit kann sich ändern – Postfächer werden gelöscht, Domains laufen ab, Catch-All-Konfigurationen ändern sich. Eine Cache-Dauer von 24 Stunden gleicht Leistung und Genauigkeit für die meisten Anwendungen aus.

// 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;

Cache-Invalidierung

Für Produktionsanwendungen mit hohem Volumen sollten Sie die Verwendung von Redis oder Memcached anstelle eines In-Memory-Cache in Betracht ziehen. Diese externen Cache-Stores bleiben über Anwendungsneustarts hinweg bestehen und können in einer geclusterten Bereitstellung zwischen mehreren Anwendungsinstanzen geteilt werden.

Testen Ihrer E-Mail-Verifizierungsintegration

Umfassende Tests stellen sicher, dass Ihre E-Mail-Verifizierungsintegration in allen Szenarien korrekt funktioniert. Unit-Tests überprüfen einzelne Komponenten, während Integrationstests die ordnungsgemäße API-Kommunikation bestätigen. Mocken Sie die HTTP-Schicht während der Unit-Tests, um tatsächliche API-Aufrufe zu vermeiden.

Unit-Tests mit 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');
  });
});

Testen von Grenzfällen

Fügen Sie Tests für Randfälle wie Netzwerkausfälle, fehlerhafte Antworten und ungewöhnliche E-Mail-Formate hinzu. Der E-Mail-Checker sollte alle Szenarien elegant behandeln, ohne Ihre Anwendung zum Absturz zu bringen.

Überwachungs- und Logging-Best-Practices

Produktionsreife E-Mail-Verifizierungsintegrationen erfordern Überwachung, um Leistung zu verfolgen, Probleme zu identifizieren und Kosten zu optimieren. Implementieren Sie strukturiertes Logging, das Verifizierungsergebnisse, Antwortzeiten und Fehlerraten erfasst.

Strukturiertes Logging

// 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;

Metrik-Tracking

Richten Sie Alarme für erhöhte Fehlerraten oder ungewöhnliche Muster ein, die auf API-Probleme oder Missbrauchsversuche hinweisen könnten. Überwachungs-Dashboards helfen Ihnen, Verifizierungsmuster zu verstehen und Ihre Implementierung im Laufe der Zeit zu optimieren.

Sicherheitsüberlegungen

E-Mail-Verifizierungsintegrationen verarbeiten potenziell sensible Daten und erfordern sorgfältige Sicherheitsüberlegungen. Schützen Sie Ihre API-Schlüssel, validieren Sie Eingaben und implementieren Sie Ratenlimits auf Ihren eigenen Endpunkten, um Missbrauch zu verhindern.

Schutz von API-Anmeldedaten

Exponieren Sie niemals Ihren BillionVerify API-Schlüssel in clientseitigem Code. Alle Verifizierungsanfragen sollten über Ihren Backend-Server geleitet werden, der die API-Anmeldeinformationen sicher aufbewahrt. Dies verhindert, dass böswillige Akteure Ihr API-Kontingent für ihre eigenen Zwecke verwenden.

Eingabevalidierung und Ratenbegrenzung

Implementieren Sie Eingabevalidierung, bevor Sie E-Mails an die Verifizierungs-API senden. Eine grundlegende Formatvalidierung auf Ihrer Seite reduziert unnötige API-Aufrufe und bietet schnelleres Feedback für offensichtlich ungültige Eingaben.

// 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;

Fazit

Die Implementierung der E-Mail-Verifizierung in Node.js-Anwendungen bietet die Grundlage für die Aufrechterhaltung hochwertiger E-Mail-Listen und den Schutz Ihrer Absenderreputation. Die in diesem Tutorial behandelten Techniken – von der grundlegenden API-Integration bis zu produktionsreifen Mustern einschließlich Caching, Fehlerbehandlung und Überwachung – statten Sie aus, um robuste E-Mail-Validierung in jede Node.js-Anwendung einzubauen.

Die BillionVerify E-Mail-Verifizierung API lässt sich nahtlos in Node.js integrieren und bietet Einzel-E-Mail-Verifizierung in Echtzeit sowie Batch-Verarbeitungsfunktionen. Die Antwortdaten ermöglichen nuancierte Entscheidungen über die E-Mail-Akzeptanz, von einfachen Gültig/Ungültig-Bestimmungen bis zu ausgeklügelter risikobasierter Filterung.

Beginnen Sie mit der grundlegenden Implementierung, um die API-Muster zu verstehen, und fügen Sie dann progressiv Caching, Überwachung und Fehlerbehandlung hinzu, wenn sich die Anforderungen Ihrer Anwendung weiterentwickeln. Die hier demonstrierten E-Mail-Checker-Muster skalieren von Startup-MVPs bis zu unternehmenstauglichen Anwendungen, die Millionen von Verifizierungen verarbeiten.

Ob Sie ein Benutzerregistrierungssystem erstellen, Marketing-Listen bereinigen oder Kontaktformular-Übermittlungen validieren – eine ordnungsgemäße E-Mail-Verifizierung schützt Ihre E-Mail-Zustellbarkeit und stellt sicher, dass Ihre Nachrichten echte Empfänger erreichen. Machen Sie den ersten Schritt, indem Sie sich für ein BillionVerify-Konto anmelden und die E-Mail-Verifizierung noch heute in Ihre Node.js-Anwendung integrieren.