Setiap email yang Anda kirim bepergian melalui jaringan server yang terkoordinasi dengan hati-hati, dan Mail Exchange (MX) record adalah penanda yang memandu perjalanan ini. Memahami cara memvalidasi MX record adalah keterampilan fundamental bagi developer yang membangun sistem verifikasi email, formulir kontak, atau aplikasi yang mengumpulkan alamat email. Panduan komprehensif ini mengeksplorasi validasi MX record dari konsep dasar hingga strategi implementasi tingkat lanjut, memberikan Anda pengetahuan untuk membangun verifikasi email yang kuat ke dalam aplikasi Anda.
Memahami MX Record
Mail Exchange record adalah DNS record yang menentukan server email mana yang bertanggung jawab menerima email atas nama sebuah domain. Ketika Anda mengirim email ke user@example.com, server email Anda perlu tahu kemana harus mengirimkannya. MX record menyediakan informasi ini dengan menunjuk ke server email domain tersebut.
Cara Kerja MX Record
Ketika email dikirim, server email pengirim melakukan DNS lookup untuk menemukan MX record domain penerima. Lookup ini mengembalikan satu atau lebih hostname server email beserta nilai prioritas yang menunjukkan urutan preferensi.
Lookup MX record khas untuk gmail.com mungkin mengembalikan:
gmail.com. MX 5 gmail-smtp-in.l.google.com. gmail.com. MX 10 alt1.gmail-smtp-in.l.google.com. gmail.com. MX 20 alt2.gmail-smtp-in.l.google.com. gmail.com. MX 30 alt3.gmail-smtp-in.l.google.com. gmail.com. MX 40 alt4.gmail-smtp-in.l.google.com.
Server pengirim mencoba pengiriman ke server dengan prioritas terendah terlebih dahulu (dalam kasus ini, prioritas 5). Jika server tersebut tidak tersedia, ia mencoba level prioritas berikutnya, dan seterusnya. Redundansi ini memastikan pengiriman email bahkan ketika server individual sedang down.
Komponen MX Record
Setiap MX record berisi dua informasi penting:
Priority (Preferensi)
Nilai numerik yang menunjukkan urutan dimana server email harus dicoba. Angka yang lebih rendah menunjukkan prioritas yang lebih tinggi. Server dengan prioritas yang sama dicoba dalam urutan acak, menyediakan load balancing.
Hostname Server Email
Fully qualified domain name (FQDN) dari server email yang menangani email untuk domain tersebut. Hostname ini harus dapat di-resolve ke alamat IP melalui A record atau AAAA record.
Mengapa MX Record Penting untuk Verifikasi Email
Validasi MX record berfungsi sebagai checkpoint kritis dalam proses verifikasi email:
Konfirmasi Eksistensi Domain
Jika sebuah domain tidak memiliki MX record, biasanya domain tersebut tidak dapat menerima email. Beberapa domain mungkin memiliki A record fallback, tetapi ketiadaan MX record sering menjadi indikator kuat bahwa domain tidak dikonfigurasi untuk email.
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:
- Selalu periksa MX record sebelum mencoba verifikasi SMTP untuk menghemat waktu dan sumber daya
- Tangani A record fallback sesuai standar RFC untuk domain tanpa MX record
- Implementasikan caching untuk mengurangi overhead DNS lookup untuk validasi berulang
- Kenali pola umum untuk mengidentifikasi penyedia email dan risiko potensial
- 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.