SMTP メール検証:送信せずにメールアドレスを確認する完全ガイド

4xx と 5xx コードの区別は非常に重要です。4xx レスポンスは一時的な問題を示唆します—メールボックスは後で利用可能になる可能性があります。5xx レスポンスは永続的な失敗を示します—アドレスは無効と見なされるべきです。

SMTP メール検証の実装

SMTP 検証システムを構築するには、プロトコルの詳細、エラー処理、レート制限に細心の注意を払う必要があります。以下は実用的な実装ガイドです。

基本的な SMTP 検証フロー

以下の擬似コードは、コア検証ロジックを示しています:

function verifyEmail(email):
    domain = extractDomain(email)

    // ステップ 1: MX レコードを取得
    mxRecords = getMXRecords(domain)
    if mxRecords is empty:
        return INVALID_DOMAIN

    // 優先度でソート(最小の数値 = 最高の優先度)
    sortByPriority(mxRecords)

    // 各 MX サーバーを試す
    for mx in mxRecords:
        try:
            // ステップ 2: 接続
            connection = connectSMTP(mx.host, 25)

            // ステップ 3: EHLO
            response = sendCommand("EHLO verifier.example.com")
            if response.code != 250:
                continue  // 次の MX を試す

            // ステップ 4: MAIL FROM
            response = sendCommand("MAIL FROM:<verify@example.com>")
            if response.code != 250:
                continue

            // ステップ 5: RCPT TO
            response = sendCommand("RCPT TO:<" + email + ">")

            // ステップ 6: QUIT
            sendCommand("QUIT")
            closeConnection()

            // 結果を解釈
            if response.code == 250:
                return VALID
            else if response.code >= 500:
                return INVALID
            else:
                return UNKNOWN

        catch ConnectionError:
            continue  // 次の MX を試す

    return UNABLE_TO_VERIFY

Node.js 実装

以下は、ネイティブの net と dns モジュールを使用した実用的な Node.js 実装です:

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

async function verifyEmailSMTP(email) {
  const domain = email.split('@')[1];

  // MX レコードを取得
  const mxRecords = await new Promise((resolve, reject) => {
    dns.resolveMx(domain, (err, addresses) => {
      if (err) reject(err);
      else resolve(addresses.sort((a, b) => a.priority - b.priority));
    });
  });

  if (!mxRecords || mxRecords.length === 0) {
    return { valid: false, reason: 'No MX records found' };
  }

  // 各 MX サーバーを試す
  for (const mx of mxRecords) {
    try {
      const result = await checkMailbox(mx.exchange, email);
      return result;
    } catch (err) {
      continue; // 次の MX サーバーを試す
    }
  }

  return { valid: null, reason: 'Unable to verify' };
}

function checkMailbox(mxHost, email) {
  return new Promise((resolve, reject) => {
    const socket = net.createConnection(25, mxHost);
    let step = 0;
    let response = '';

    socket.setTimeout(10000);

    socket.on('data', (data) => {
      response = data.toString();
      const code = parseInt(response.substring(0, 3));

      switch (step) {
        case 0: // サーバーの挨拶
          if (code === 220) {
            socket.write('EHLO verifier.example.com\r\n');
            step++;
          } else {
            socket.end();
            reject(new Error('Server rejected connection'));
          }
          break;

        case 1: // EHLO レスポンス
          if (code === 250) {
            socket.write('MAIL FROM:<verify@example.com>\r\n');
            step++;
          } else {
            socket.end();
            reject(new Error('EHLO failed'));
          }
          break;

        case 2: // MAIL FROM レスポンス
          if (code === 250) {
            socket.write(`RCPT TO:<${email}>\r\n`);
            step++;
          } else {
            socket.end();
            reject(new Error('MAIL FROM rejected'));
          }
          break;

        case 3: // RCPT TO レスポンス - 検証結果
          socket.write('QUIT\r\n');
          socket.end();

          if (code === 250) {
            resolve({ valid: true, reason: 'Mailbox exists' });
          } else if (code >= 500) {
            resolve({ valid: false, reason: 'Mailbox does not exist', code });
          } else {
            resolve({ valid: null, reason: 'Unable to determine', code });
          }
          break;
      }
    });

    socket.on('timeout', () => {
      socket.end();
      reject(new Error('Connection timeout'));
    });

    socket.on('error', (err) => {
      reject(err);
    });
  });
}

Python 実装

Python は smtplib モジュールでクリーンな SMTP 検証を提供します:

import dns.resolver
import smtplib
import socket

def verify_email_smtp(email):
    domain = email.split('@')[1]

    # MX レコードを取得
    try:
        mx_records = dns.resolver.resolve(domain, 'MX')
        mx_hosts = sorted([(r.preference, str(r.exchange).rstrip('.'))
                          for r in mx_records])
    except dns.resolver.NXDOMAIN:
        return {'valid': False, 'reason': 'Domain does not exist'}
    except dns.resolver.NoAnswer:
        return {'valid': False, 'reason': 'No MX records found'}

    # 各 MX サーバーを試す
    for priority, mx_host in mx_hosts:
        try:
            result = check_mailbox(mx_host, email)
            if result['valid'] is not None:
                return result
        except Exception as e:
            continue

    return {'valid': None, 'reason': 'Unable to verify'}

def check_mailbox(mx_host, email):
    try:
        # SMTP サーバーに接続
        smtp = smtplib.SMTP(timeout=10)
        smtp.connect(mx_host, 25)

        # EHLO
        code, message = smtp.ehlo('verifier.example.com')
        if code != 250:
            smtp.quit()
            return {'valid': None, 'reason': 'EHLO failed'}

        # MAIL FROM
        code, message = smtp.mail('verify@example.com')
        if code != 250:
            smtp.quit()
            return {'valid': None, 'reason': 'MAIL FROM rejected'}

        # RCPT TO - 検証ステップ
        code, message = smtp.rcpt(email)
        smtp.quit()

        if code == 250:
            return {'valid': True, 'reason': 'Mailbox exists'}
        elif code >= 500:
            return {'valid': False, 'reason': 'Mailbox does not exist', 'code': code}
        else:
            return {'valid': None, 'reason': 'Temporary failure', 'code': code}

    except socket.timeout:
        return {'valid': None, 'reason': 'Connection timeout'}
    except smtplib.SMTPServerDisconnected:
        return {'valid': None, 'reason': 'Server disconnected'}
    except Exception as e:
        return {'valid': None, 'reason': str(e)}

SMTP メール検証における課題

SMTP 検証は強力ですが、いくつかの課題が実装を複雑にし、精度に影響を与える可能性があります。

キャッチオールドメイン

一部のメールサーバーはキャッチオールとして設定されており、特定のメールボックスが存在するかどうかに関係なく、そのドメインの任意のアドレス宛てのメールを受け入れます。ランダムな文字を含む任意のアドレスに対して RCPT TO を送信しても、サーバーは 250 OK で応答します。

キャッチオール設定により、SMTP 検証ではそのドメイン上の有効なアドレスと無効なアドレスを区別できなくなります。BillionVerify のようなプロフェッショナルなメール検証サービスは、これらのドメインを識別し、適切な信頼度スコアを提供するための特殊なキャッチオール検出アルゴリズムを実装しています。

グレイリスティング

グレイリスティングは、未知の送信者からのメールを一時的に拒否するスパム対策技術です。最初の SMTP 接続試行は 4xx の一時的なエラーを返します。正当なメールサーバーは配信を再試行しますが、多くのスパムシステムは再試行しません。

メール検証の場合、グレイリスティングは一時的な失敗として表示されます。適切な実装には次が必要です:

• グレイリスティングレスポンスの認識(多くの場合 450 または 451)
• 適切な遅延を伴う再試行ロジックの実装
• グレイリスティングを使用するサーバーの追跡

レート制限とブロッキング

メールサーバーは、接続をレート制限することで悪用から自身を保護します。単一の IP アドレスからの短時間での過度の検証試行は、以下をトリガーする可能性があります:

• 一時的なブロック(4xx レスポンス)
• 永続的なブラックリスト登録
• 接続タイムアウト
• CAPTCHA やチャレンジ

プロフェッショナルなメール検証サービスは、多くの IP アドレスに検証リクエストを分散し、これらの保護をトリガーしないように高度なレート制限を実装しています。

偽陽性と偽陰性

SMTP 検証は 100% 正確ではありません。いくつかのシナリオで誤った結果が生成される可能性があります:

偽陽性(無効を有効として報告)

• すべてを受け入れるキャッチオールドメイン
• SMTP 中は受け入れるが後でバウンスするサーバー
• 接続は受け入れるが満杯のメールボックス

偽陰性(有効を無効として報告)

• 最初の試行を拒否するグレイリスティング
• 正当なチェックをブロックするレート制限
• サーバーの設定ミス
• 一時的な停止

SMTP サーバーのバリエーション

異なるメールサーバーは、検証に影響を与えるバリエーションを持つ SMTP を実装しています:

Microsoft Exchange/Office 365

• 詳細なレスポンスには認証が必要な場合が多い
• SMTP 中は受け入れるが後で配信を拒否する場合がある
• 高度なスパム対策を実装

Gmail/Google Workspace

• 受け入れ/拒否については一般的に信頼できる
• 積極的な検証試行をレート制限する場合がある
• 一貫したレスポンスを返す

Yahoo Mail

• 厳格なレート制限で知られている
• チャレンジの解決が必要な場合がある
• グレイリスティングを実装

カスタムメールサーバー

• 動作は大きく異なる
• 非標準の設定がある場合がある
• セキュリティ設定が検証精度に影響する

SMTP メール検証のベストプラクティス

信頼性の高い SMTP 検証を構築するには、実証済みのベストプラクティスに従う必要があります。

適切な EHLO/HELO 設定

EHLO ホスト名は以下を満たす必要があります:

• 検証サーバーの IP に解決される
• 有効な逆引き DNS(PTR レコード)を持つ
• ブラックリストに載っていない
• 管理する正当なドメインである

EHLO verify.yourdomain.com

スパムフィルターをトリガーする一般的または疑わしいホスト名は避けてください。

MAIL FROM アドレスの選択

MAIL FROM アドレスは検証の受け入れに重要です:

• 有効な MX レコードを持つ実際のドメインを使用する
• SPF レコードが検証サーバーを許可していることを確認する
• 検証専用のドメインの使用を検討する
• 既知のスパムトラップドメインを避ける

接続管理

効率的な接続管理により、検証速度と信頼性が向上します:

// 接続プーリングの例
class SMTPConnectionPool {
  constructor(maxConnections = 10) {
    this.pools = new Map(); // ドメイン -> 接続
    this.maxConnections = maxConnections;
  }

  async getConnection(mxHost) {
    if (!this.pools.has(mxHost)) {
      this.pools.set(mxHost, []);
    }

    const pool = this.pools.get(mxHost);

    // 利用可能な場合は既存の接続を再利用
    if (pool.length > 0) {
      return pool.pop();
    }

    // 新しい接続を作成
    return await this.createConnection(mxHost);
  }

  releaseConnection(mxHost, connection) {
    const pool = this.pools.get(mxHost);
    if (pool && pool.length < this.maxConnections) {
      pool.push(connection);
    } else {
      connection.end();
    }
  }
}

タイムアウト設定

応答しないサーバーでハングするのを避けるために、適切なタイムアウトを設定します:

const TIMEOUT_CONFIG = {
  connection: 10000,    // 接続確立に 10 秒
  greeting: 30000,      // サーバー挨拶に 30 秒
  command: 30000,       // コマンドレスポンスごとに 30 秒
  total: 60000          // 検証ごとに最大 60 秒
};

エラー処理と再試行ロジック

インテリジェントな再試行を伴う堅牢なエラー処理を実装します:

async function verifyWithRetry(email, maxRetries = 3) {
  const delays = [1000, 5000, 15000]; // 指数バックオフ

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const result = await verifyEmailSMTP(email);

      // 明確な答えが得られた場合は再試行しない
      if (result.valid !== null) {
        return result;
      }

      // エラーが再試行可能かチェック
      if (isGreylisting(result) || isTemporaryError(result)) {
        await sleep(delays[attempt]);
        continue;
      }

      return result;

    } catch (err) {
      if (attempt === maxRetries - 1) {
        return { valid: null, reason: err.message };
      }
      await sleep(delays[attempt]);
    }
  }
}

function isGreylisting(result) {
  return result.code === 450 || result.code === 451;
}

function isTemporaryError(result) {
  return result.code >= 400 && result.code < 500;
}

レート制限の実装

検証インフラストラクチャを保護し、良好な評判を維持します:

class RateLimiter {
  constructor() {
    this.domainLimits = new Map();
    this.globalCounter = 0;
    this.globalLimit = 100; // 秒あたり
    this.domainLimit = 10;  // ドメインごと秒あたり
  }

  async waitForSlot(domain) {
    // グローバル制限をチェック
    while (this.globalCounter >= this.globalLimit) {
      await sleep(100);
    }

    // ドメイン制限をチェック
    const domainCount = this.domainLimits.get(domain) || 0;
    while (domainCount >= this.domainLimit) {
      await sleep(100);
    }

    // スロットを予約
    this.globalCounter++;
    this.domainLimits.set(domain, domainCount + 1);

    // 1秒後に解放
    setTimeout(() => {
      this.globalCounter--;
      this.domainLimits.set(domain,
        (this.domainLimits.get(domain) || 1) - 1);
    }, 1000);
  }
}

SMTP 検証と他の方法の比較

SMTP 検証が他のメールバリデーション技術とどのように比較されるかを理解することで、適切なアプローチを選択できます。

構文検証

構文検証は、正規表現パターンを使用してメールアドレスが正しい形式に従っているかチェックします。高速でクライアント側で実行できますが、明らかな形式エラーのみをキャッチします。

強み:

• 即座の結果
• ネットワークリクエスト不要
• タイプミスをキャッチ

制限:

• 存在を確認できない
• 多くの無効なメールが構文チェックを通過

ドメイン/MX 検証

MX レコード検証は、メールサーバーレコードをチェックすることでドメインがメールを受信できることを確認します。

強み:

• 存在しないドメインをキャッチ
• 高速な DNS ルックアップ
• SMTP 接続不要

制限:

• 特定のメールボックスを確認できない
• ドメインに MX があっても有効なユーザーがいない場合がある

SMTP 検証

SMTP 検証は、特定のメールボックスが存在し、メールを受信できることを確認します。

強み:

• メールボックスの存在に対する最高の精度
• メールサーバーとの直接通信
• 多くの無効なアドレスをキャッチ

制限:

• 他の方法より遅い
• キャッチオールドメインの影響を受ける
• レート制限によりブロックされる可能性

検証階層

包括的なメール検証戦略は、これらの方法を階層化します:

1. 構文検証 - 明らかに無効な形式をフィルタリング
2. ドメイン検証 - ドメインが存在し MX レコードを持つことを確認
3. SMTP 検証 - 特定のメールボックスを確認
4. 追加チェック - 使い捨てメール検出、ロールベース検出、キャッチオール検出

BillionVerify のようなプロフェッショナルなメール検証サービスは、この完全な階層を実装し、SMTP 検証の複雑さを処理しながら、メール品質に関する追加のインテリジェンスを提供します。

プロフェッショナルな SMTP 検証サービスの使用

独自の SMTP 検証システムを構築することは教育的ですが、本番アプリケーションは複雑さを処理するプロフェッショナルなメール検証 API から恩恵を受けることがよくあります。

プロフェッショナルサービスの利点

インフラストラクチャ

• 世界中に分散された検証サーバー
• クリーンな IP レピュテーション管理
• 高可用性と冗長性

インテリジェンス

• キャッチオールドメイン検出
• 使い捨てメール識別
• ロールベースアドレスのフラグ設定
• スパムトラップ検出

コンプライアンス

• プライバシーに準拠した処理
• 安全なデータ処理
• 監査証跡

BillionVerify API 統合

BillionVerify は SMTP チェックを含む包括的なメール検証を提供します:

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

  const result = await response.json();

  return {
    isValid: result.is_valid,
    isDeliverable: result.is_deliverable,
    isCatchAll: result.is_catch_all,
    isDisposable: result.is_disposable,
    isRoleBased: result.is_role_based,
    smtpCheck: result.smtp_check,
    mxRecords: result.mx_records,
    riskScore: result.risk_score
  };
}

API は内部的にすべての SMTP の複雑さを処理しながら、複製するには大きなインフラストラクチャが必要な追加のインテリジェンスを提供します。

一括 SMTP 検証

大規模なメールリストを検証する場合、一括検証はプロセスを最適化します:

async function bulkVerify(emails) {
  // バッチ処理用のファイルをアップロード
  const formData = new FormData();
  formData.append('file', createCSV(emails));

  const uploadResponse = await fetch('https://api.billionverify.com/v1/bulk/upload', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY'
    },
    body: formData
  });

  const { jobId } = await uploadResponse.json();

  // 完了をポーリング
  let status = 'processing';
  while (status === 'processing') {
    await sleep(5000);
    const statusResponse = await fetch(
      `https://api.billionverify.com/v1/bulk/status/${jobId}`,
      { headers: { 'Authorization': 'Bearer YOUR_API_KEY' } }
    );
    const job = await statusResponse.json();
    status = job.status;
  }

  // 結果をダウンロード
  const resultsResponse = await fetch(
    `https://api.billionverify.com/v1/bulk/download/${jobId}`,
    { headers: { 'Authorization': 'Bearer YOUR_API_KEY' } }
  );

  return await resultsResponse.json();
}

サインアップフォーム向けリアルタイム SMTP 検証

ユーザー登録中にリアルタイムのメール検証を実装することで、最初からデータ品質が向上します。

フロントエンド実装

// 入力時のデバウンスされたメール検証
const emailInput = document.getElementById('email');
let verificationTimeout;

emailInput.addEventListener('input', (e) => {
  clearTimeout(verificationTimeout);

  const email = e.target.value;
  if (!isValidSyntax(email)) {
    showError('有効なメール形式を入力してください');
    return;
  }

  verificationTimeout = setTimeout(async () => {
    showLoading();

    try {
      const result = await verifyEmail(email);

      if (result.isValid) {
        showSuccess('メールが確認されました');
      } else if (result.isCatchAll) {
        showWarning('このメールを完全に確認できません');
      } else {
        showError('このメールアドレスは無効のようです');
      }
    } catch (err) {
      // 検証エラーでサインアップをブロックしない
      clearStatus();
    }
  }, 500); // 入力停止後 500ms 待機
});

async function verifyEmail(email) {
  const response = await fetch('/api/verify-email', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email })
  });
  return response.json();
}

バックエンド API エンドポイント

// Express.js エンドポイント
app.post('/api/verify-email', async (req, res) => {
  const { email } = req.body;

  // まず簡単な構文チェック
  if (!isValidEmailSyntax(email)) {
    return res.json({ isValid: false, reason: 'Invalid syntax' });
  }

  try {
    // 完全な検証のために BillionVerify API を呼び出す
    const result = await emailVerify.verify(email);

    res.json({
      isValid: result.is_valid && result.is_deliverable,
      isCatchAll: result.is_catch_all,
      isDisposable: result.is_disposable,
      suggestion: result.did_you_mean // タイプミスの提案
    });
  } catch (err) {
    // フェイルオープン - API エラーでサインアップをブロックしない
    res.json({ isValid: true, verified: false });
  }
});

SMTP 検証のセキュリティ上の考慮事項

SMTP 検証には、セキュリティ意識を必要とするネットワーク接続が含まれます。

インフラストラクチャの保護

ファイアウォール設定

• 検証サーバーからのアウトバウンド SMTP 接続のみを許可
• 異常な接続パターンを監視
• 既知の悪意のある IP 範囲をブロック

TLS/SSL の使用

• 利用可能な場合は STARTTLS を使用
• サーバー証明書を検証
• 証明書エラーを適切に処理

ブラックリスト登録の回避

検証サーバーがスパムを送信しているように見える場合、またはメールサーバーを悪用している場合、ブラックリストに登録される可能性があります:

• 厳格なレート制限を実装
• 検証専用の IP を使用
• ブラックリストのステータスを定期的に監視
• 適切な逆引き DNS を維持
• 悪用の苦情に迅速に対応

データプライバシー

メールアドレスは保護が必要な個人データです:

• 完全なメールアドレスを不必要にログに記録しない
• 保存された検証結果を暗号化
• データ保持ポリシーを実装
• GDPR およびその他の規制に準拠
• API 呼び出しには安全な接続を使用

SMTP 検証のパフォーマンス測定

検証システムが適切に機能していることを確認するために、主要な指標を追跡します。

主要指標

精度指標

• 真陽性率(有効を正しく識別)
• 偽陽性率(無効を有効としてマーク)
• キャッチオール検出精度
• 不明/確認不可能率

パフォーマンス指標

• 平均検証時間
• 95 パーセンタイルレスポンス時間
• 接続成功率
• ドメイン別タイムアウト率

運用指標

• 日次検証ボリューム
• タイプ別エラー率
• ブラックリストインシデント
• API 可用性

監視ダッシュボードの例

class VerificationMetrics {
  constructor() {
    this.counters = {
      total: 0,
      valid: 0,
      invalid: 0,
      catchAll: 0,
      unknown: 0,
      errors: 0
    };
    this.timings = [];
  }

  record(result, duration) {
    this.counters.total++;
    this.timings.push(duration);

    if (result.valid === true) this.counters.valid++;
    else if (result.valid === false) this.counters.invalid++;
    else if (result.isCatchAll) this.counters.catchAll++;
    else this.counters.unknown++;
  }

  recordError() {
    this.counters.errors++;
  }

  getStats() {
    const sortedTimings = this.timings.sort((a, b) => a - b);

    return {
      counts: this.counters,
      accuracy: {
        validRate: this.counters.valid / this.counters.total,
        unknownRate: this.counters.unknown / this.counters.total
      },
      performance: {
        avgTime: average(this.timings),
        p95Time: sortedTimings[Math.floor(sortedTimings.length * 0.95)],
        errorRate: this.counters.errors / this.counters.total
      }
    };
  }
}

結論

SMTP メール検証は、メールアドレスがメッセージを受信できるかどうかを確認するための最も正確な方法を提供します。SMTP プロトコルを使用してメールサーバーと直接通信することで、実際にメールを送信することなくメールボックスの存在を判断できます。

効果的な SMTP 検証を構築するには、プロトコルの詳細を理解し、キャッチオールドメインやグレイリスティングなどのさまざまな課題を処理し、適切なレート制限とエラー処理を実装する必要があります。ほとんどの本番アプリケーションでは、BillionVerify のようなプロフェッショナルなメール検証サービスが、検証インフラストラクチャを構築および維持する複雑さなしに、必要なインフラストラクチャ、インテリジェンス、信頼性を提供します。

学習目的で独自の SMTP 検証を実装する場合でも、プロフェッショナルなメール検証 API を統合する場合でも、このガイドで説明した原則は、大規模にメールアドレスを検証する際の舞台裏で何が起こっているかを理解するのに役立ちます。

SMTP 検証は包括的なメールバリデーションの一要素にすぎないことを忘れないでください。構文検証、ドメイン検証、使い捨てメール検出、キャッチオール識別と組み合わせることで、送信者レピュテーションを保護し、メール配信性を向上させ、メールリストの品質を維持する完全なメール検証戦略が作成されます。

即座のフィードバックのために基本的な構文とドメインチェックから始め、徹底的な検証のために SMTP 検証を階層化し、専用のメール検証インフラストラクチャから得られる信頼性、精度、追加のインテリジェンスが必要な場合は BillionVerify のようなプロフェッショナルサービスを検討してください。