MX Record Validatie: Gids voor Ontwikkelaars

Infrastructuurverificatie

Geldige MX records die oplossen naar werkende mailservers geven aan dat het domein e-mailinfrastructuur heeft. Dit garandeert niet dat een specifiek adres bestaat, maar bevestigt wel dat het domein e-mail kan ontvangen.

Spam en Fraudedetectie

Legitieme bedrijven onderhouden correcte MX records. Verdachte domeinen die worden gebruikt voor spam of fraude hebben vaak verkeerd geconfigureerde of ontbrekende MX records.

Prestatieoptimalisatie

Het controleren van MX records voordat je SMTP-verificatie probeert, voorkomt verspilde tijd bij het verbinden met domeinen die geen e-mail kunnen ontvangen.

MX Record Lookups Implementeren

Laten we verkennen hoe je MX record validatie implementeert in verschillende programmeeromgevingen.

Node.js Implementatie

Node.js biedt ingebouwde DNS-resolutie via de dns module:

const dns = require('dns').promises;

async function getMxRecords(domain) {
  try {
    const records = await dns.resolveMx(domain);

    // Sort by priority (lowest first)
    records.sort((a, b) => a.priority - b.priority);

    return {
      success: true,
      domain,
      records: records.map(r => ({
        exchange: r.exchange,
        priority: r.priority
      }))
    };
  } catch (error) {
    return {
      success: false,
      domain,
      error: error.code,
      message: getMxErrorMessage(error.code)
    };
  }
}

function getMxErrorMessage(code) {
  const messages = {
    'ENODATA': 'No MX records found for this domain',
    'ENOTFOUND': 'Domain does not exist',
    'ETIMEOUT': 'DNS lookup timed out',
    'ESERVFAIL': 'DNS server failed to respond'
  };
  return messages[code] || 'Unknown DNS error';
}

// Usage
const result = await getMxRecords('gmail.com');
console.log(result);

Python Implementatie

Python's dns.resolver module uit de dnspython bibliotheek biedt uitgebreide DNS lookup mogelijkheden:

import dns.resolver
import dns.exception

def get_mx_records(domain):
    try:
        answers = dns.resolver.resolve(domain, 'MX')

        records = []
        for rdata in answers:
            records.append({
                'exchange': str(rdata.exchange).rstrip('.'),
                'priority': rdata.preference
            })

        # Sort by priority
        records.sort(key=lambda x: x['priority'])

        return {
            'success': True,
            'domain': domain,
            'records': records
        }

    except dns.resolver.NXDOMAIN:
        return {
            'success': False,
            'domain': domain,
            'error': 'NXDOMAIN',
            'message': 'Domain does not exist'
        }

    except dns.resolver.NoAnswer:
        return {
            'success': False,
            'domain': domain,
            'error': 'NoAnswer',
            'message': 'No MX records found for this domain'
        }

    except dns.exception.Timeout:
        return {
            'success': False,
            'domain': domain,
            'error': 'Timeout',
            'message': 'DNS lookup timed out'
        }

# Usage
result = get_mx_records('gmail.com')
print(result)

Go Implementatie

Go's net package biedt eenvoudige DNS lookup functies:

package main

import (
    "fmt"
    "net"
    "sort"
)

type MxResult struct {
    Success bool
    Domain  string
    Records []MxRecord
    Error   string
}

type MxRecord struct {
    Exchange string
    Priority uint16
}

func getMxRecords(domain string) MxResult {
    records, err := net.LookupMX(domain)

    if err != nil {
        return MxResult{
            Success: false,
            Domain:  domain,
            Error:   err.Error(),
        }
    }

    if len(records) == 0 {
        return MxResult{
            Success: false,
            Domain:  domain,
            Error:   "No MX records found",
        }
    }

    // Sort by priority
    sort.Slice(records, func(i, j int) bool {
        return records[i].Pref < records[j].Pref
    })

    result := MxResult{
        Success: true,
        Domain:  domain,
        Records: make([]MxRecord, len(records)),
    }

    for i, r := range records {
        result.Records[i] = MxRecord{
            Exchange: r.Host,
            Priority: r.Pref,
        }
    }

    return result
}

func main() {
    result := getMxRecords("gmail.com")
    fmt.Printf("%+v\n", result)
}

Geavanceerde MX Validatietechnieken

Basis MX lookups bevestigen dat records bestaan, maar uitgebreide e-mailvalidatie vereist diepere analyse.

Mailserver Connectiviteit Valideren

MX records verwijzen naar hostnamen die moeten oplossen naar IP-adressen. Verifieer dat de mailservers daadwerkelijk bereikbaar zijn:

const dns = require('dns').promises;
const net = require('net');

async function validateMxConnectivity(domain) {
  // Get MX records
  const mxResult = await getMxRecords(domain);

  if (!mxResult.success) {
    return mxResult;
  }

  // Validate each mail server
  const validatedRecords = [];

  for (const record of mxResult.records) {
    const validation = await validateMailServer(record.exchange);
    validatedRecords.push({
      ...record,
      ...validation
    });
  }

  return {
    success: true,
    domain,
    records: validatedRecords,
    hasReachableServer: validatedRecords.some(r => r.reachable)
  };
}

async function validateMailServer(hostname) {
  try {
    // Resolve hostname to IP
    const addresses = await dns.resolve4(hostname);

    if (addresses.length === 0) {
      return { reachable: false, error: 'No A record' };
    }

    // Test connection to port 25
    const connected = await testConnection(addresses[0], 25);

    return {
      reachable: connected,
      ip: addresses[0],
      error: connected ? null : 'Connection refused'
    };
  } catch (error) {
    return {
      reachable: false,
      error: error.message
    };
  }
}

function testConnection(host, port, timeout = 5000) {
  return new Promise((resolve) => {
    const socket = new net.Socket();

    socket.setTimeout(timeout);

    socket.on('connect', () => {
      socket.destroy();
      resolve(true);
    });

    socket.on('timeout', () => {
      socket.destroy();
      resolve(false);
    });

    socket.on('error', () => {
      resolve(false);
    });

    socket.connect(port, host);
  });
}

A Record Fallback Afhandelen

Wanneer er geen MX records bestaan, specificeren e-mailstandaarden (RFC 5321) dat het A record van het domein als fallback gebruikt moet worden. Implementeer deze fallback in je validatie:

async function getMailServers(domain) {
  // Try MX records first
  try {
    const mxRecords = await dns.resolveMx(domain);

    if (mxRecords.length > 0) {
      return {
        type: 'MX',
        servers: mxRecords.sort((a, b) => a.priority - b.priority)
      };
    }
  } catch (error) {
    if (error.code !== 'ENODATA') {
      throw error;
    }
  }

  // Fallback to A record
  try {
    const aRecords = await dns.resolve4(domain);

    if (aRecords.length > 0) {
      return {
        type: 'A_FALLBACK',
        servers: [{ exchange: domain, priority: 0 }],
        warning: 'Using A record fallback - no MX records found'
      };
    }
  } catch (error) {
    if (error.code !== 'ENODATA') {
      throw error;
    }
  }

  return {
    type: 'NONE',
    servers: [],
    error: 'No mail servers found for domain'
  };
}

Null MX Records Detecteren

RFC 7505 definieert "null MX" records die expliciet aangeven dat een domein geen e-mail accepteert. Deze records hebben een enkel MX entry met prioriteit 0 en een lege hostnaam ("."):

function hasNullMx(mxRecords) {
  if (mxRecords.length === 1) {
    const record = mxRecords[0];
    if (record.priority === 0 &&
        (record.exchange === '.' || record.exchange === '')) {
      return true;
    }
  }
  return false;
}

async function validateDomainMx(domain) {
  const mxResult = await getMxRecords(domain);

  if (!mxResult.success) {
    return mxResult;
  }

  if (hasNullMx(mxResult.records)) {
    return {
      success: false,
      domain,
      error: 'NULL_MX',
      message: 'Domain explicitly does not accept email'
    };
  }

  return mxResult;
}

MX Lookups Cachen

DNS lookups voegen latency toe aan elke verificatie. Implementeer caching om de prestaties te verbeteren:

class MxCache {
  constructor(ttlMs = 3600000) { // 1 hour default TTL
    this.cache = new Map();
    this.ttl = ttlMs;
  }

  get(domain) {
    const entry = this.cache.get(domain.toLowerCase());

    if (!entry) return null;

    if (Date.now() > entry.expiry) {
      this.cache.delete(domain.toLowerCase());
      return null;
    }

    return entry.data;
  }

  set(domain, data) {
    this.cache.set(domain.toLowerCase(), {
      data,
      expiry: Date.now() + this.ttl
    });
  }

  // Respect DNS TTL values when available
  setWithTtl(domain, data, ttlSeconds) {
    const ttlMs = Math.min(ttlSeconds * 1000, this.ttl);
    this.cache.set(domain.toLowerCase(), {
      data,
      expiry: Date.now() + ttlMs
    });
  }
}

const mxCache = new MxCache();

async function getMxRecordsCached(domain) {
  const cached = mxCache.get(domain);

  if (cached) {
    return { ...cached, fromCache: true };
  }

  const result = await getMxRecords(domain);

  if (result.success) {
    mxCache.set(domain, result);
  }

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

Veelvoorkomende MX Record Patronen

Het begrijpen van veelvoorkomende MX configuraties helpt je validatieresultaten te interpreteren en potentiële problemen te identificeren.

Grote E-mailproviders

Het herkennen van MX patronen voor grote providers kan helpen gratis e-mailadressen te identificeren:

const knownProviders = {
  'google': [
    'gmail-smtp-in.l.google.com',
    'googlemail-smtp-in.l.google.com',
    'aspmx.l.google.com'
  ],
  'microsoft': [
    'outlook-com.olc.protection.outlook.com',
    'mail.protection.outlook.com'
  ],
  'yahoo': [
    'mta5.am0.yahoodns.net',
    'mta6.am0.yahoodns.net',
    'mta7.am0.yahoodns.net'
  ],
  'protonmail': [
    'mail.protonmail.ch',
    'mailsec.protonmail.ch'
  ]
};

function identifyEmailProvider(mxRecords) {
  const exchanges = mxRecords.map(r => r.exchange.toLowerCase());

  for (const [provider, patterns] of Object.entries(knownProviders)) {
    for (const pattern of patterns) {
      if (exchanges.some(ex => ex.includes(pattern.toLowerCase()))) {
        return provider;
      }
    }
  }

  return 'unknown';
}

Google Workspace Detectie

Google Workspace (voorheen G Suite) domeinen gebruiken Google's mailservers maar zijn geen gratis e-mailaccounts:

function isGoogleWorkspace(domain, mxRecords) {
  const isGoogleMx = mxRecords.some(r =>
    r.exchange.toLowerCase().includes('google') ||
    r.exchange.toLowerCase().includes('googlemail')
  );

  // Check if domain is not a known Google consumer domain
  const googleConsumerDomains = ['gmail.com', 'googlemail.com'];
  const isConsumerDomain = googleConsumerDomains.includes(domain.toLowerCase());

  return isGoogleMx && !isConsumerDomain;
}

Zelf-gehoste E-mail Detectie

Domeinen die hun eigen e-mail hosten, hebben vaak MX records die verwijzen naar subdomeinen:

function isSelfHosted(domain, mxRecords) {
  const domainParts = domain.toLowerCase().split('.');
  const baseDomain = domainParts.slice(-2).join('.');

  return mxRecords.some(r => {
    const exchange = r.exchange.toLowerCase();
    return exchange.includes(baseDomain) &&
           !isKnownProvider(exchange);
  });
}

function isKnownProvider(exchange) {
  const providers = ['google', 'microsoft', 'yahoo', 'outlook', 'protonmail'];
  return providers.some(p => exchange.includes(p));
}

MX Validatie in E-mailverificatie Pipelines

MX validatie is een stap in een uitgebreid e-mailverificatieproces. Het begrijpen van zijn rol helpt effectieve verificatiepipelines te bouwen.

Verificatievolgorde

MX validatie vindt doorgaans vroeg in de verificatiepipeline plaats:

async function verifyEmail(email) {
  // 1. Syntax validation (fastest, no network)
  const syntaxResult = validateEmailSyntax(email);
  if (!syntaxResult.valid) {
    return { valid: false, reason: 'invalid_syntax', details: syntaxResult };
  }

  const domain = email.split('@')[1];

  // 2. MX record validation (fast DNS lookup)
  const mxResult = await validateMxRecords(domain);
  if (!mxResult.valid) {
    return { valid: false, reason: 'no_mx_records', details: mxResult };
  }

  // 3. Additional checks (disposable, role-based, etc.)
  const domainCheck = await checkDomainReputation(domain);
  if (domainCheck.isDisposable) {
    return { valid: true, risky: true, reason: 'disposable_domain' };
  }

  // 4. SMTP verification (slowest, most thorough)
  const smtpResult = await verifySmtp(email, mxResult.records);

  return {
    valid: smtpResult.exists,
    deliverable: smtpResult.deliverable,
    mxRecords: mxResult.records,
    provider: mxResult.provider
  };
}

Parallelle MX Lookups

Bij het verifiëren van meerdere e-mails, parallelliseer MX lookups voor verschillende domeinen:

async function verifyEmailsBatch(emails) {
  // Group emails by domain
  const emailsByDomain = {};

  for (const email of emails) {
    const domain = email.split('@')[1];
    if (!emailsByDomain[domain]) {
      emailsByDomain[domain] = [];
    }
    emailsByDomain[domain].push(email);
  }

  // Lookup MX records for all domains in parallel
  const domains = Object.keys(emailsByDomain);
  const mxResults = await Promise.all(
    domains.map(domain => getMxRecordsCached(domain))
  );

  // Map results back to domains
  const mxByDomain = {};
  domains.forEach((domain, index) => {
    mxByDomain[domain] = mxResults[index];
  });

  // Process emails with MX data
  const results = [];

  for (const email of emails) {
    const domain = email.split('@')[1];
    const mx = mxByDomain[domain];

    if (!mx.success) {
      results.push({ email, valid: false, reason: 'invalid_domain' });
      continue;
    }

    // Continue with SMTP verification using cached MX data
    const smtpResult = await verifySmtp(email, mx.records);
    results.push({ email, ...smtpResult });
  }

  return results;
}

Foutafhandeling en Randgevallen

Robuuste MX validatie handelt verschillende foutcondities netjes af.

DNS Timeout Afhandeling

Netwerkproblemen kunnen ervoor zorgen dat DNS lookups vastlopen. Implementeer timeout afhandeling:

async function getMxRecordsWithTimeout(domain, timeoutMs = 10000) {
  const timeoutPromise = new Promise((_, reject) => {
    setTimeout(() => reject(new Error('DNS_TIMEOUT')), timeoutMs);
  });

  try {
    const result = await Promise.race([
      getMxRecords(domain),
      timeoutPromise
    ]);
    return result;
  } catch (error) {
    if (error.message === 'DNS_TIMEOUT') {
      return {
        success: false,
        domain,
        error: 'TIMEOUT',
        message: 'DNS lookup timed out',
        retryable: true
      };
    }
    throw error;
  }
}

Ongeldige Domein Afhandeling

Behandel domeinen die syntactisch ongeldig zijn voordat je DNS lookups probeert:

function isValidDomain(domain) {
  if (!domain || typeof domain !== 'string') {
    return false;
  }

  // Check length
  if (domain.length > 253) {
    return false;
  }

  // Check for valid characters and structure
  const domainRegex = /^(?!-)[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}$/;

  if (!domainRegex.test(domain)) {
    return false;
  }

  // Check each label length
  const labels = domain.split('.');
  for (const label of labels) {
    if (label.length > 63) {
      return false;
    }
  }

  return true;
}

async function validateDomainMxSafe(domain) {
  if (!isValidDomain(domain)) {
    return {
      success: false,
      domain,
      error: 'INVALID_DOMAIN',
      message: 'Domain format is invalid'
    };
  }

  return await getMxRecordsWithTimeout(domain);
}

Tijdelijke DNS Fouten Afhandelen

DNS fouten kunnen tijdelijk zijn. Implementeer retry logica met exponential backoff:

async function getMxRecordsWithRetry(domain, maxRetries = 3) {
  const delays = [1000, 2000, 4000];

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const result = await getMxRecordsWithTimeout(domain);

    // Don't retry for definitive failures
    if (result.success ||
        result.error === 'NXDOMAIN' ||
        result.error === 'ENOTFOUND') {
      return result;
    }

    // Retry for temporary failures
    if (result.retryable && attempt < maxRetries - 1) {
      await sleep(delays[attempt]);
      continue;
    }

    return result;
  }
}

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

Beveiligingsoverwegingen

MX validatie introduceert beveiligingsoverwegingen die ontwikkelaars moeten aanpakken.

DNS Spoofing Preventie

Standaard DNS queries zijn onversleuteld en kwetsbaar voor spoofing. Overweeg DNS over HTTPS (DoH) te gebruiken voor gevoelige applicaties:

const https = require('https');

async function getMxRecordsDoH(domain) {
  const url = `https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(domain)}&type=MX`;

  return new Promise((resolve, reject) => {
    https.get(url, {
      headers: { 'Accept': 'application/dns-json' }
    }, (res) => {
      let data = '';

      res.on('data', chunk => data += chunk);

      res.on('end', () => {
        try {
          const response = JSON.parse(data);

          if (response.Status !== 0) {
            resolve({
              success: false,
              domain,
              error: 'DNS_ERROR',
              status: response.Status
            });
            return;
          }

          const records = (response.Answer || [])
            .filter(a => a.type === 15)
            .map(a => {
              const [priority, exchange] = a.data.split(' ');
              return {
                priority: parseInt(priority),
                exchange: exchange.replace(/\.$/, '')
              };
            })
            .sort((a, b) => a.priority - b.priority);

          resolve({
            success: records.length > 0,
            domain,
            records
          });
        } catch (error) {
          reject(error);
        }
      });
    }).on('error', reject);
  });
}

Rate Limiting DNS Queries

Voorkom misbruik door de snelheid van DNS queries te beperken:

class DnsRateLimiter {
  constructor(maxQueriesPerSecond = 100) {
    this.tokens = maxQueriesPerSecond;
    this.maxTokens = maxQueriesPerSecond;
    this.lastRefill = Date.now();
  }

  async acquire() {
    this.refillTokens();

    if (this.tokens > 0) {
      this.tokens--;
      return true;
    }

    // Wait for token availability
    await sleep(1000 / this.maxTokens);
    return this.acquire();
  }

  refillTokens() {
    const now = Date.now();
    const elapsed = now - this.lastRefill;
    const tokensToAdd = (elapsed / 1000) * this.maxTokens;

    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
    this.lastRefill = now;
  }
}

const dnsLimiter = new DnsRateLimiter(50);

async function getMxRecordsRateLimited(domain) {
  await dnsLimiter.acquire();
  return getMxRecords(domain);
}

BillionVerify Gebruiken voor MX Validatie

Hoewel het zelf implementeren van MX validatie educatieve waarde biedt, behandelen professionele e-mailverificatieservices zoals BillionVerify MX validatie als onderdeel van uitgebreide e-mailverificatie.

Voordelen van een E-mailverificatie API Gebruiken

Uitgebreide Controles

BillionVerify's e-mailverificatie API combineert MX validatie met syntaxcontrole, SMTP-verificatie, detectie van wegwerp-e-mail en meer in een enkele API call. Dit elimineert de noodzaak om meerdere validatiesystemen te onderhouden.

Geoptimaliseerde Infrastructuur

Professionele services onderhouden wereldwijd verspreide DNS resolvers, handelen caching op schaal af en optimaliseren voor prestaties over miljoenen verificaties.

Continue Updates

Mailserver configuraties veranderen constant. E-mailverificatieservices updaten voortdurend hun databases van bekende providers, wegwerpdomeinen en mailserver patronen.

API Integratie Voorbeeld

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

  const result = await response.json();

  // MX information is included in the response
  console.log('MX Valid:', result.mx_found);
  console.log('Domain Valid:', result.domain_valid);
  console.log('Is Deliverable:', result.is_deliverable);

  return result;
}

Conclusie

MX record validatie is een fundamenteel onderdeel van e-mailverificatie dat bevestigt dat een domein e-mail kan ontvangen voordat meer resource-intensieve controles worden geprobeerd. Door correcte MX validatie te implementeren, kun je snel ongeldige domeinen filteren, verificatieprestaties optimaliseren en betrouwbaardere e-mailverwerkende applicaties bouwen.

Belangrijkste lessen voor MX record validatie:

1. Controleer altijd MX records voordat je SMTP-verificatie probeert om tijd en resources te besparen
2. Behandel de A record fallback volgens RFC-standaarden voor domeinen zonder MX records
3. Implementeer caching om DNS lookup overhead te verminderen voor herhaalde validaties
4. Herken veelvoorkomende patronen om e-mailproviders en potentiële risico's te identificeren
5. Behandel fouten netjes met timeouts, retries en correcte foutmeldingen

Of je nu een aangepast e-mailverificatiesysteem bouwt of integreert met een service zoals BillionVerify, het begrijpen van MX records helpt je betere e-mailafhandeling in je applicaties te bouwen. Begin vandaag nog met het implementeren van MX validatie en zet de eerste stap naar uitgebreide e-mailverificatie.

Teams die Instantly of Smartlead gebruiken, verbeteren hun bezorgbaarheid door lijsten met BillionVerify te reinigen voor elke campagne.

Vergelijk BillionVerify met ZeroBounce op nauwkeurigheid en snelheid voordat u een verificatieprovider kiest.