Validasi MX Record: Panduan Developer

Verifikasi Infrastruktur

MX record yang valid yang dapat di-resolve ke server email yang berfungsi menunjukkan bahwa domain memiliki infrastruktur email. Ini tidak menjamin alamat spesifik ada, tetapi mengonfirmasi bahwa domain dapat menerima email.

Deteksi Spam dan Penipuan

Bisnis yang sah memiliki MX record yang tepat. Domain mencurigakan yang digunakan untuk spam atau penipuan sering memiliki MX record yang salah konfigurasi atau tidak ada.

Optimasi Performa

Memeriksa MX record sebelum mencoba verifikasi SMTP menghindari waktu terbuang untuk terhubung ke domain yang tidak dapat menerima email.

Mengimplementasikan MX Record Lookup

Mari kita eksplorasi cara mengimplementasikan validasi MX record dalam berbagai lingkungan pemrograman.

Implementasi Node.js

Node.js menyediakan resolusi DNS bawaan melalui modul dns:

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

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

    // Urutkan berdasarkan prioritas (terendah dulu)
    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': 'Tidak ada MX record yang ditemukan untuk domain ini',
    'ENOTFOUND': 'Domain tidak ada',
    'ETIMEOUT': 'DNS lookup timeout',
    'ESERVFAIL': 'Server DNS gagal merespons'
  };
  return messages[code] || 'Error DNS tidak diketahui';
}

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

Implementasi Python

Modul dns.resolver Python dari library dnspython menyediakan kemampuan DNS lookup yang komprehensif:

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
            })

        # Urutkan berdasarkan prioritas
        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 tidak ada'
        }

    except dns.resolver.NoAnswer:
        return {
            'success': False,
            'domain': domain,
            'error': 'NoAnswer',
            'message': 'Tidak ada MX record yang ditemukan untuk domain ini'
        }

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

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

Implementasi Go

Package net Go menyediakan fungsi DNS lookup yang mudah:

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",
        }
    }

    // Urutkan berdasarkan prioritas
    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)
}

Teknik Validasi MX Tingkat Lanjut

MX lookup dasar mengonfirmasi bahwa record ada, tetapi validasi email yang komprehensif memerlukan analisis yang lebih mendalam.

Memvalidasi Konektivitas Server Email

MX record menunjuk ke hostname yang harus dapat di-resolve ke alamat IP. Verifikasi bahwa server email benar-benar dapat dijangkau:

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

async function validateMxConnectivity(domain) {
  // Dapatkan MX record
  const mxResult = await getMxRecords(domain);

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

  // Validasi setiap server email
  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 ke IP
    const addresses = await dns.resolve4(hostname);

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

    // Tes koneksi ke port 25
    const connected = await testConnection(addresses[0], 25);

    return {
      reachable: connected,
      ip: addresses[0],
      error: connected ? null : 'Koneksi ditolak'
    };
  } 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);
  });
}

Menangani A Record Fallback

Ketika tidak ada MX record, standar email (RFC 5321) menentukan bahwa A record domain harus digunakan sebagai fallback. Implementasikan fallback ini dalam validasi Anda:

async function getMailServers(domain) {
  // Coba MX record terlebih dahulu
  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 ke A record
  try {
    const aRecords = await dns.resolve4(domain);

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

  return {
    type: 'NONE',
    servers: [],
    error: 'Tidak ada server email yang ditemukan untuk domain'
  };
}

Mendeteksi Null MX Record

RFC 7505 mendefinisikan "null MX" record yang secara eksplisit menunjukkan bahwa domain tidak menerima email. Record ini memiliki satu MX entry dengan prioritas 0 dan hostname kosong ("."):

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 secara eksplisit tidak menerima email'
    };
  }

  return mxResult;
}

Caching MX Lookup

DNS lookup menambahkan latensi pada setiap verifikasi. Implementasikan caching untuk meningkatkan performa:

class MxCache {
  constructor(ttlMs = 3600000) { // TTL default 1 jam
    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
    });
  }

  // Hormati nilai TTL DNS ketika tersedia
  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 };
}

Pola MX Record yang Umum

Memahami konfigurasi MX yang umum membantu Anda menginterpretasi hasil validasi dan mengidentifikasi masalah potensial.

Penyedia Email Besar

Mengenali pola MX untuk penyedia besar dapat membantu mengidentifikasi alamat email gratis:

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

Deteksi Google Workspace

Domain Google Workspace (sebelumnya G Suite) menggunakan server email Google tetapi bukan akun email gratis:

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

  // Periksa apakah domain bukan domain konsumen Google yang dikenal
  const googleConsumerDomains = ['gmail.com', 'googlemail.com'];
  const isConsumerDomain = googleConsumerDomains.includes(domain.toLowerCase());

  return isGoogleMx && !isConsumerDomain;
}

Deteksi Email Self-Hosted

Domain yang meng-host email mereka sendiri sering memiliki MX record yang menunjuk ke subdomain:

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

Validasi MX dalam Pipeline Verifikasi Email

Validasi MX adalah salah satu langkah dalam proses verifikasi email yang komprehensif. Memahami perannya membantu membangun pipeline verifikasi yang efektif.

Urutan Verifikasi

Validasi MX biasanya terjadi di awal pipeline verifikasi:

async function verifyEmail(email) {
  // 1. Validasi sintaks (tercepat, tanpa jaringan)
  const syntaxResult = validateEmailSyntax(email);
  if (!syntaxResult.valid) {
    return { valid: false, reason: 'invalid_syntax', details: syntaxResult };
  }

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

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

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

  // 4. Verifikasi SMTP (paling lambat, paling menyeluruh)
  const smtpResult = await verifySmtp(email, mxResult.records);

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

MX Lookup Paralel

Ketika memverifikasi beberapa email, paralelkan MX lookup untuk domain yang berbeda:

async function verifyEmailsBatch(emails) {
  // Kelompokkan email berdasarkan domain
  const emailsByDomain = {};

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

  // Lookup MX record untuk semua domain secara paralel
  const domains = Object.keys(emailsByDomain);
  const mxResults = await Promise.all(
    domains.map(domain => getMxRecordsCached(domain))
  );

  // Petakan hasil kembali ke domain
  const mxByDomain = {};
  domains.forEach((domain, index) => {
    mxByDomain[domain] = mxResults[index];
  });

  // Proses email dengan data MX
  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;
    }

    // Lanjutkan dengan verifikasi SMTP menggunakan data MX yang di-cache
    const smtpResult = await verifySmtp(email, mx.records);
    results.push({ email, ...smtpResult });
  }

  return results;
}

Penanganan Error dan Edge Case

Validasi MX yang kuat menangani berbagai kondisi error dengan baik.

Penanganan DNS Timeout

Masalah jaringan dapat menyebabkan DNS lookup hang. Implementasikan penanganan timeout:

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 timeout',
        retryable: true
      };
    }
    throw error;
  }
}

Penanganan Domain Tidak Valid

Tangani domain yang secara sintaksis tidak valid sebelum mencoba DNS lookup:

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

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

  // Periksa karakter dan struktur yang valid
  const domainRegex = /^(?!-)[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}$/;

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

  // Periksa panjang setiap label
  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: 'Format domain tidak valid'
    };
  }

  return await getMxRecordsWithTimeout(domain);
}

Menangani Kegagalan DNS Sementara

Kegagalan DNS mungkin bersifat sementara. Implementasikan logika retry dengan 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);

    // Jangan retry untuk kegagalan definitif
    if (result.success ||
        result.error === 'NXDOMAIN' ||
        result.error === 'ENOTFOUND') {
      return result;
    }

    // Retry untuk kegagalan sementara
    if (result.retryable && attempt < maxRetries - 1) {
      await sleep(delays[attempt]);
      continue;
    }

    return result;
  }
}

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

Pertimbangan Keamanan

Validasi MX memperkenalkan pertimbangan keamanan yang harus ditangani oleh developer.

Pencegahan DNS Spoofing

DNS query standar tidak terenkripsi dan rentan terhadap spoofing. Pertimbangkan menggunakan DNS over HTTPS (DoH) untuk aplikasi sensitif:

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 Query

Cegah penyalahgunaan dengan membatasi rate DNS query:

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

    // Tunggu ketersediaan token
    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);
}

Menggunakan BillionVerify untuk Validasi MX

Meskipun mengimplementasikan validasi MX sendiri memberikan nilai edukatif, layanan verifikasi email profesional seperti BillionVerify menangani validasi MX sebagai bagian dari verifikasi email yang komprehensif.

Keuntungan Menggunakan Email Verification API

Pemeriksaan Komprehensif

Email verification API BillionVerify menggabungkan validasi MX dengan pengecekan sintaks, verifikasi SMTP, deteksi email disposable, dan banyak lagi dalam satu API call. Ini menghilangkan kebutuhan untuk memelihara beberapa sistem validasi.

Infrastruktur yang Dioptimalkan

Layanan profesional memelihara DNS resolver yang terdistribusi secara global, menangani caching dalam skala besar, dan mengoptimalkan performa di seluruh jutaan verifikasi.

Update Berkelanjutan

Konfigurasi server email berubah secara konstan. Layanan verifikasi email terus memperbarui database mereka tentang penyedia yang dikenal, domain disposable, dan pola server email.

Contoh Integrasi API

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();

  // Informasi MX termasuk dalam respons
  console.log('MX Valid:', result.mx_found);
  console.log('Domain Valid:', result.domain_valid);
  console.log('Is Deliverable:', result.is_deliverable);

  return result;
}

Kesimpulan

Validasi MX record adalah komponen fundamental dari verifikasi email yang mengonfirmasi bahwa domain dapat menerima email sebelum mencoba pengecekan yang lebih intensif sumber daya. Dengan mengimplementasikan validasi MX yang tepat, Anda dapat dengan cepat menyaring domain yang tidak valid, mengoptimalkan performa verifikasi, dan membangun aplikasi penanganan email yang lebih andal.

Poin penting untuk validasi MX record:

1. Selalu periksa MX record sebelum mencoba verifikasi SMTP untuk menghemat waktu dan sumber daya
2. Tangani A record fallback sesuai standar RFC untuk domain tanpa MX record
3. Implementasikan caching untuk mengurangi overhead DNS lookup untuk validasi berulang
4. Kenali pola umum untuk mengidentifikasi penyedia email dan risiko potensial
5. Tangani error dengan baik dengan timeout, retry, dan pesan error yang tepat

Baik Anda membangun sistem verifikasi email kustom atau berintegrasi dengan layanan seperti BillionVerify, memahami MX record membantu Anda membangun penanganan email yang lebih baik ke dalam aplikasi Anda. Mulai implementasikan validasi MX hari ini dan ambil langkah pertama menuju verifikasi email yang komprehensif.

Tim yang menggunakan Instantly atau Smartlead meningkatkan deliverabilitas dengan membersihkan daftar melalui BillionVerify sebelum setiap kampanye.

Bandingkan BillionVerify dengan ZeroBounce dalam hal akurasi dan kecepatan sebelum memilih penyedia verifikasi.