開発者のためのメール検証:完全な技術実装ガイド

基本的な正規表現検証を超えて

正規表現は明らかなフォーマットエラーをキャッチしますが、追加のチェックにより検証精度が向上します。これらには、連続したドットのチェック、トップレベルドメインの長さの検証、一般的なタイプミスパターンの検出が含まれます。

function enhancedSyntaxValidation(email) {
  const basicResult = validateEmailSyntax(email);
  if (!basicResult.valid) return basicResult;

  const normalizedEmail = basicResult.email;
  const [localPart, domain] = normalizedEmail.split('@');

  // 連続したドットをチェック
  if (localPart.includes('..') || domain.includes('..')) {
    return { valid: false, error: 'Consecutive dots not allowed' };
  }

  // 先頭/末尾のドットをチェック
  if (localPart.startsWith('.') || localPart.endsWith('.')) {
    return { valid: false, error: 'Local part cannot start or end with dot' };
  }

  // TLDを検証
  const tld = domain.split('.').pop();
  if (tld.length < 2 || tld.length > 63) {
    return { valid: false, error: 'Invalid top-level domain' };
  }

  // 数字のみのTLDをチェック(無効)
  if (/^\d+$/.test(tld)) {
    return { valid: false, error: 'TLD cannot be numeric only' };
  }

  return { valid: true, email: normalizedEmail };
}

DNS と MX レコード検証

構文検証の後、DNS 検証は有効な MX レコードを確認することで、メールドメインがメールを受信できることを検証します。

MX レコードの理解

メール交換(MX)レコードは、ドメインのメールを受け入れる責任があるメールサーバーを指定する DNS レコードです。各 MX レコードには優先度値とホスト名が含まれており、ドメインがフェイルオーバーを持つ複数のメールサーバーを設定できるようになっています。

user@example.com にメールを送信する場合、送信サーバーは example.com の MX レコードについて DNS をクエリし、応答する最高優先度(最小番号)のメールサーバーに接続します。

Node.js での MX ルックアップの実装

Node.js は dns モジュールを通じて組み込みの DNS 解決を提供し、MX 検証を簡単に実装できます。

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

async function validateMXRecords(domain) {
  try {
    const mxRecords = await dns.resolveMx(domain);

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

    // 優先度でソート(低い方が高優先度)
    const sortedRecords = mxRecords.sort((a, b) => a.priority - b.priority);

    return {
      valid: true,
      domain,
      mxRecords: sortedRecords,
      primaryMX: sortedRecords[0].exchange
    };
  } catch (error) {
    if (error.code === 'ENOTFOUND' || error.code === 'ENODATA') {
      return {
        valid: false,
        error: 'Domain does not exist or has no MX records',
        domain
      };
    }

    return {
      valid: false,
      error: `DNS lookup failed: ${error.message}`,
      domain
    };
  }
}

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

  // まずMXレコードを試す
  const mxResult = await validateMXRecords(domain);
  if (mxResult.valid) return mxResult;

  // Aレコードチェックにフォールバック(一部のドメインはMXなしでメールを受け入れる)
  try {
    const aRecords = await dns.resolve4(domain);
    if (aRecords && aRecords.length > 0) {
      return {
        valid: true,
        domain,
        mxRecords: [],
        fallbackToA: true,
        aRecords
      };
    }
  } catch (error) {
    // Aレコードのルックアップも失敗
  }

  return mxResult;
}

DNS エッジケースの処理

本番環境のメール検証は、タイムアウト、一時的な障害、異常な構成を持つドメインなど、さまざまな DNS エッジケースを処理する必要があります。

async function robustDNSValidation(email, options = {}) {
  const { timeout = 5000, retries = 2 } = options;
  const domain = email.split('@')[1];

  for (let attempt = 0; attempt <= retries; attempt++) {
    try {
      const controller = new AbortController();
      const timeoutId = setTimeout(() => controller.abort(), timeout);

      const result = await validateEmailDomain(email);
      clearTimeout(timeoutId);

      return result;
    } catch (error) {
      if (attempt === retries) {
        return {
          valid: false,
          error: 'DNS validation failed after retries',
          domain,
          temporary: true
        };
      }

      // 指数バックオフ
      await new Promise(resolve =>
        setTimeout(resolve, Math.pow(2, attempt) * 100)
      );
    }
  }
}

SMTP 検証の実装

SMTP 検証は、受信者のメールサーバーに直接クエリしてメールボックスが存在することを確認することで、最高の精度を提供します。

SMTP 検証の仕組み

SMTP 検証は、実際にメッセージを配信せずにメールを送信する最初のステップをシミュレートします。検証プロセスは、メールサーバーへの接続を確立し、EHLO/HELO で自己紹介し、MAIL FROM で送信者アドレスを提供し、次に RCPT TO でターゲットアドレスへの送信を要求します。

RCPT TO への メールサーバーの応答は、メールボックスが存在するかどうかを示します。250 応答はアドレスが有効であることを確認し、550 はユーザーが存在しないことを示します。ただし、現在多くのサーバーがキャッチオールの構成やグレイリストを使用しており、このプロセスを複雑にしています。

Node.js での基本的な SMTP 検証

const net = require('net');

class SMTPVerifier {
  constructor(options = {}) {
    this.timeout = options.timeout || 10000;
    this.fromEmail = options.fromEmail || 'verify@example.com';
    this.fromDomain = options.fromDomain || 'example.com';
  }

  async verify(email, mxHost) {
    return new Promise((resolve) => {
      const socket = new net.Socket();
      let step = 0;
      let response = '';

      const cleanup = () => {
        socket.destroy();
      };

      socket.setTimeout(this.timeout);

      socket.on('timeout', () => {
        cleanup();
        resolve({ valid: false, error: 'Connection timeout' });
      });

      socket.on('error', (error) => {
        cleanup();
        resolve({ valid: false, error: error.message });
      });

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

        switch (step) {
          case 0: // 接続、挨拶を受信
            if (code === 220) {
              socket.write(`EHLO ${this.fromDomain}\r\n`);
              step = 1;
            } else {
              cleanup();
              resolve({ valid: false, error: 'Invalid greeting' });
            }
            break;

          case 1: // EHLO応答
            if (code === 250) {
              socket.write(`MAIL FROM:<${this.fromEmail}>\r\n`);
              step = 2;
            } else {
              cleanup();
              resolve({ valid: false, error: 'EHLO rejected' });
            }
            break;

          case 2: // MAIL FROM応答
            if (code === 250) {
              socket.write(`RCPT TO:<${email}>\r\n`);
              step = 3;
            } else {
              cleanup();
              resolve({ valid: false, error: 'MAIL FROM rejected' });
            }
            break;

          case 3: // RCPT TO応答 - 検証結果
            socket.write('QUIT\r\n');
            cleanup();

            if (code === 250) {
              resolve({ valid: true, email });
            } else if (code === 550 || code === 551 || code === 552 || code === 553) {
              resolve({ valid: false, error: 'Mailbox does not exist', code });
            } else if (code === 450 || code === 451 || code === 452) {
              resolve({ valid: false, error: 'Temporary failure', temporary: true, code });
            } else {
              resolve({ valid: false, error: `Unknown response: ${code}`, code });
            }
            break;
        }
      });

      socket.connect(25, mxHost);
    });
  }
}

SMTP の課題への対処

実世界の SMTP 検証は、グレイリスト、レート制限、キャッチオールドメインなど、多数の課題に直面します。開発者は、これらの状況を処理するための戦略を実装する必要があります。

async function comprehensiveSMTPVerification(email, mxRecords) {
  const verifier = new SMTPVerifier({
    fromEmail: 'verify@yourdomain.com',
    fromDomain: 'yourdomain.com',
    timeout: 15000
  });

  // 優先順位に従って各MXサーバーを試す
  for (const mx of mxRecords) {
    const result = await verifier.verify(email, mx.exchange);

    // 決定的な答えが得られた場合、それを返す
    if (result.valid || (!result.temporary && result.code === 550)) {
      return result;
    }

    // 一時的な障害や接続の問題の場合、次のサーバーを試す
    if (result.temporary || result.error.includes('timeout')) {
      continue;
    }

    // その他のエラーの場合、結果を返す
    return result;
  }

  return {
    valid: false,
    error: 'All MX servers failed',
    temporary: true
  };
}

メール検証 API の使用

カスタム検証の構築は教育的ですが、本番アプリケーションはプロフェッショナルなメール配信性を確保するため、BillionVerify のようなメール検証 API を使用することで恩恵を受けることがよくあります。

メール検証 API を使用する理由

プロフェッショナルなメール検証サービスは、カスタム実装に比べていくつかの利点を提供します。既知の使い捨てメールプロバイダー、キャッチオールドメイン、スパムトラップの広範なデータベースを維持しています。また、ブロックされることなく大量の SMTP 検証に必要なインフラストラクチャを管理します。

BillionVerify のメール検証 API は、構文チェック、DNS 検証、SMTP 検証、使い捨てメール検出、配信可能性スコアリングを含む包括的な検証を、シンプルな REST API を通じて提供します。

BillionVerify API の統合

const axios = require('axios');

class BillionVerifyClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = 'https://api.billionverify.com/v1';
  }

  async verifySingle(email) {
    try {
      const response = await axios.get(`${this.baseURL}/verify`, {
        params: { email },
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        }
      });

      return {
        success: true,
        data: response.data
      };
    } catch (error) {
      return {
        success: false,
        error: error.response?.data?.message || error.message
      };
    }
  }

  async verifyBatch(emails) {
    try {
      const response = await axios.post(`${this.baseURL}/verify/batch`, {
        emails
      }, {
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        }
      });

      return {
        success: true,
        data: response.data
      };
    } catch (error) {
      return {
        success: false,
        error: error.response?.data?.message || error.message
      };
    }
  }
}

// 使用例
async function validateUserEmail(email) {
  const client = new BillionVerifyClient(process.env.BV_API_KEY);
  const result = await client.verifySingle(email);

  if (!result.success) {
    console.error('Verification failed:', result.error);
    return { valid: false, error: 'Verification service unavailable' };
  }

  const { data } = result;

  return {
    valid: data.deliverable,
    email: data.email,
    status: data.status,
    isDisposable: data.is_disposable,
    isCatchAll: data.is_catch_all,
    score: data.quality_score
  };
}

ウェブアプリケーションでのリアルタイム検証

ウェブアプリケーションでリアルタイムメール検証を実装するには、ユーザーエクスペリエンスとパフォーマンスを慎重に考慮する必要があります。

フロントエンド検証戦略

フロントエンド検証は、明らかなエラーに対して即座のフィードバックを提供し、包括的な検証をバックエンドに延期する必要があります。このアプローチは、ユーザーエクスペリエンスとセキュリティのバランスを取ります。

// デバウンス付きフロントエンドメール検証
class EmailValidator {
  constructor(options = {}) {
    this.debounceMs = options.debounceMs || 500;
    this.onValidating = options.onValidating || (() => {});
    this.onResult = options.onResult || (() => {});
    this.pendingRequest = null;
    this.debounceTimer = null;
  }

  validateSyntax(email) {
    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return regex.test(email);
  }

  async validate(email) {
    // 保留中のリクエストをクリア
    if (this.debounceTimer) {
      clearTimeout(this.debounceTimer);
    }

    // 即座の構文チェック
    if (!this.validateSyntax(email)) {
      this.onResult({
        valid: false,
        error: 'Please enter a valid email address'
      });
      return;
    }

    // API呼び出しのデバウンス
    this.debounceTimer = setTimeout(async () => {
      this.onValidating(true);

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

        const result = await response.json();
        this.onResult(result);
      } catch (error) {
        this.onResult({
          valid: false,
          error: 'Unable to verify email'
        });
      } finally {
        this.onValidating(false);
      }
    }, this.debounceMs);
  }
}

// Reactコンポーネントの例
function EmailInput() {
  const [email, setEmail] = useState('');
  const [status, setStatus] = useState({ checking: false, result: null });

  const validator = useMemo(() => new EmailValidator({
    onValidating: (checking) => setStatus(s => ({ ...s, checking })),
    onResult: (result) => setStatus(s => ({ ...s, result }))
  }), []);

  const handleChange = (e) => {
    const value = e.target.value;
    setEmail(value);
    if (value) validator.validate(value);
  };

  return (
    <div className="email-input">
      <input
        type="email"
        value={email}
        onChange={handleChange}
        placeholder="Enter your email"
      />
      {status.checking && <span className="loading">Verifying...</span>}
      {status.result && (
        <span className={status.result.valid ? 'valid' : 'invalid'}>
          {status.result.valid ? '✓ Valid email' : status.result.error}
        </span>
      )}
    </div>
  );
}

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

バックエンド API エンドポイントは、レート制限を通じて悪用から保護しながら、包括的な検証を実装する必要があります。

const express = require('express');
const rateLimit = require('express-rate-limit');

const app = express();

// 検証エンドポイントのレート制限
const verifyLimiter = rateLimit({
  windowMs: 60 * 1000, // 1分
  max: 10, // IPあたり1分あたり10リクエスト
  message: { error: 'Too many verification requests' }
});

app.post('/api/verify-email', verifyLimiter, async (req, res) => {
  const { email } = req.body;

  if (!email) {
    return res.status(400).json({ valid: false, error: 'Email required' });
  }

  try {
    // レイヤー1:構文検証
    const syntaxResult = enhancedSyntaxValidation(email);
    if (!syntaxResult.valid) {
      return res.json(syntaxResult);
    }

    // レイヤー2:DNS検証
    const dnsResult = await robustDNSValidation(syntaxResult.email);
    if (!dnsResult.valid) {
      return res.json(dnsResult);
    }

    // レイヤー3:APIベースの包括的検証
    const apiResult = await validateUserEmail(syntaxResult.email);

    res.json(apiResult);
  } catch (error) {
    console.error('Verification error:', error);
    res.status(500).json({ valid: false, error: 'Verification failed' });
  }
});

使い捨てメールと一時メールの検出

使い捨てメールアドレスは、本物のユーザーエンゲージメントを必要とするアプリケーションにとって重大な課題をもたらします。これらのアドレスを検出してブロックすることは、リストの品質を維持するために不可欠です。

使い捨てメールの理解

Guerrilla Mail、10MinuteMail、Mailinator などの使い捨てメールサービスは、ユーザーが登録なしで即座に作成できる一時的なアドレスを提供します。これらのサービスには正当な用途がありますが、多くの場合、登録要件を回避したり、偽アカウントを作成したりするために使用されます。

使い捨てメール検出器の構築

class DisposableEmailDetector {
  constructor() {
    // 一般的な使い捨てメールドメイン
    this.knownDisposable = new Set([
      'guerrillamail.com', 'guerrillamail.org',
      '10minutemail.com', '10minutemail.net',
      'mailinator.com', 'mailinator.net',
      'tempmail.com', 'tempmail.net',
      'throwaway.email', 'throwawaymail.com',
      'fakeinbox.com', 'trashmail.com',
      'getnada.com', 'temp-mail.org',
      'mohmal.com', 'emailondeck.com'
      // さらに既知の使い捨てドメインを追加
    ]);

    // 使い捨てサービスを示すことが多いパターン
    this.suspiciousPatterns = [
      /^temp/i,
      /^trash/i,
      /^throw/i,
      /^fake/i,
      /^disposable/i,
      /\d{2,}mail/i,
      /minutemail/i
    ];
  }

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

    // 既知の使い捨てドメインをチェック
    if (this.knownDisposable.has(domain)) {
      return { isDisposable: true, reason: 'Known disposable domain' };
    }

    // 疑わしいパターンをチェック
    for (const pattern of this.suspiciousPatterns) {
      if (pattern.test(domain)) {
        return { isDisposable: true, reason: 'Suspicious domain pattern' };
      }
    }

    return { isDisposable: false };
  }

  async updateDisposableList() {
    // 維持されているソースから更新されたリストを取得
    try {
      const response = await fetch(
        'https://raw.githubusercontent.com/disposable-email-domains/disposable-email-domains/master/disposable_email_blocklist.conf'
      );
      const text = await response.text();
      const domains = text.split('\n').filter(d => d.trim());

      domains.forEach(domain => this.knownDisposable.add(domain.toLowerCase()));

      return { success: true, count: this.knownDisposable.size };
    } catch (error) {
      return { success: false, error: error.message };
    }
  }
}

パフォーマンス最適化戦略

メール検証は、慎重に実装しないとアプリケーションのパフォーマンスに影響を与える可能性があります。これらの最適化戦略は、高速な応答時間を維持するのに役立ちます。

検証結果のキャッシュ

キャッシュは、冗長な検証リクエストを削減し、繰り返しの検証の応答時間を改善します。

const NodeCache = require('node-cache');

class CachedEmailVerifier {
  constructor(options = {}) {
    this.cache = new NodeCache({
      stdTTL: options.ttl || 3600, // デフォルト1時間
      checkperiod: options.checkperiod || 600
    });
    this.verifier = options.verifier;
  }

  async verify(email) {
    const normalizedEmail = email.toLowerCase().trim();
    const cacheKey = `email:${normalizedEmail}`;

    // まずキャッシュをチェック
    const cached = this.cache.get(cacheKey);
    if (cached) {
      return { ...cached, fromCache: true };
    }

    // 検証を実行
    const result = await this.verifier.verify(normalizedEmail);

    // 結果をキャッシュ(一時的な障害はキャッシュしない)
    if (!result.temporary) {
      this.cache.set(cacheKey, result);
    }

    return result;
  }

  invalidate(email) {
    const normalizedEmail = email.toLowerCase().trim();
    this.cache.del(`email:${normalizedEmail}`);
  }

  getStats() {
    return this.cache.getStats();
  }
}

リクエストキューイングの実装

大量のアプリケーションの場合、リクエストキューイングは検証サービスを圧倒することを防ぎ、公平なリソース配分を保証します。

const Queue = require('bull');

const verificationQueue = new Queue('email-verification', {
  redis: { host: 'localhost', port: 6379 },
  defaultJobOptions: {
    attempts: 3,
    backoff: {
      type: 'exponential',
      delay: 1000
    }
  }
});

// 検証ジョブを処理
verificationQueue.process(async (job) => {
  const { email, userId } = job.data;

  const result = await comprehensiveEmailVerification(email);

  // 結果をデータベースに保存
  await updateUserEmailStatus(userId, result);

  return result;
});

// 検証リクエストをキューに入れる
async function queueEmailVerification(email, userId) {
  const job = await verificationQueue.add({
    email,
    userId
  }, {
    priority: 1,
    delay: 0
  });

  return job.id;
}

エラー処理とロギング

堅牢なエラー処理と包括的なロギングは、信頼性の高いメール検証システムを維持するために不可欠です。

包括的なエラー処理の実装

class EmailVerificationError extends Error {
  constructor(message, code, details = {}) {
    super(message);
    this.name = 'EmailVerificationError';
    this.code = code;
    this.details = details;
    this.timestamp = new Date().toISOString();
  }
}

async function safeEmailVerification(email) {
  const startTime = Date.now();

  try {
    // 入力を検証
    if (!email || typeof email !== 'string') {
      throw new EmailVerificationError(
        'Invalid email input',
        'INVALID_INPUT',
        { received: typeof email }
      );
    }

    const result = await comprehensiveEmailVerification(email);

    // 成功した検証をログに記録
    logger.info('Email verification completed', {
      email: maskEmail(email),
      valid: result.valid,
      duration: Date.now() - startTime
    });

    return result;

  } catch (error) {
    // コンテキストを含むエラーをログに記録
    logger.error('Email verification failed', {
      email: maskEmail(email),
      error: error.message,
      code: error.code,
      duration: Date.now() - startTime,
      stack: error.stack
    });

    // 安全なエラー応答を返す
    return {
      valid: false,
      error: 'Verification failed',
      errorCode: error.code || 'UNKNOWN_ERROR',
      temporary: true
    };
  }
}

function maskEmail(email) {
  const [local, domain] = email.split('@');
  const maskedLocal = local.charAt(0) + '***' + local.charAt(local.length - 1);
  return `${maskedLocal}@${domain}`;
}

セキュリティに関する考慮事項

メール検証システムは、悪用を防止し、ユーザーデータを保護するためにセキュリティを念頭に置いて設計する必要があります。

列挙攻撃の防止

攻撃者は、メール検証エンドポイントを使用して有効なメールアドレスを列挙する可能性があります。この攻撃ベクトルに対する防御を実装します。

const crypto = require('crypto');

function secureVerificationResponse(result, options = {}) {
  const { hideDetails = true } = options;

  // タイミング攻撃を防ぐために一貫した応答タイミングを追加
  const minResponseTime = 200;
  const elapsed = Date.now() - result.startTime;
  const delay = Math.max(0, minResponseTime - elapsed);

  return new Promise(resolve => {
    setTimeout(() => {
      if (hideDetails && !result.valid) {
        // メールが存在するかドメインが無効かを明らかにしない
        resolve({
          valid: false,
          message: 'Unable to verify email address'
        });
      } else {
        resolve(result);
      }
    }, delay);
  });
}

レート制限と悪用防止

検証エンドポイントの悪用を防ぐために包括的なレート制限を実装します。

const rateLimit = require('express-rate-limit');
const RedisStore = require('rate-limit-redis');

const verificationRateLimiter = rateLimit({
  store: new RedisStore({
    client: redisClient,
    prefix: 'rl:verify:'
  }),
  windowMs: 60 * 1000, // 1分
  max: 5, // 1分あたり5リクエスト
  keyGenerator: (req) => {
    // 認証済みの場合はIPとユーザーIDを組み合わせる
    const userId = req.user?.id || 'anonymous';
    return `${req.ip}:${userId}`;
  },
  handler: (req, res) => {
    res.status(429).json({
      error: 'Too many verification requests',
      retryAfter: Math.ceil(req.rateLimit.resetTime / 1000)
    });
  }
});

メール検証システムのテスト

包括的なテストにより、メール検証システムがすべてのシナリオで正しく機能することが保証されます。

検証関数の単体テスト

const { expect } = require('chai');

describe('Email Syntax Validation', () => {
  it('should accept valid email addresses', () => {
    const validEmails = [
      'user@example.com',
      'user.name@example.com',
      'user+tag@example.com',
      'user@subdomain.example.com'
    ];

    validEmails.forEach(email => {
      const result = validateEmailSyntax(email);
      expect(result.valid).to.be.true;
    });
  });

  it('should reject invalid email addresses', () => {
    const invalidEmails = [
      'invalid',
      '@example.com',
      'user@',
      'user@@example.com',
      'user@example',
      'user@.com'
    ];

    invalidEmails.forEach(email => {
      const result = validateEmailSyntax(email);
      expect(result.valid).to.be.false;
    });
  });

  it('should handle edge cases', () => {
    expect(validateEmailSyntax('')).to.have.property('valid', false);
    expect(validateEmailSyntax(null)).to.have.property('valid', false);
    expect(validateEmailSyntax(undefined)).to.have.property('valid', false);
  });
});

まとめ

開発者としてメール検証を実装するには、基本的な構文チェックから高度な SMTP 検証まで、複数の検証レイヤーを理解する必要があります。ローカル検証、DNS ルックアップ、BillionVerify のようなプロフェッショナルな検証 API を組み合わせることで、開発者は優れたユーザーエクスペリエンスを提供しながら、高いデータ品質を維持する堅牢なシステムを構築できます。

メール検証実装を成功させるための重要な原則には、包括的なカバレッジのための複数の検証レイヤーの使用、パフォーマンスとセキュリティのための適切なキャッシュとレート制限の実装、エッジケースとエラーの適切な処理、検証精度の継続的な監視と改善が含まれます。

カスタム検証ロジックを実装するか、プロフェッショナルな API を活用するかにかかわらず、このガイドでカバーされている技術は、アプリケーションとユーザーを保護しながら、最高水準の配信可能性とエンゲージメントを維持するメール検証システムを構築するための基盤を提供します。

今すぐ BillionVerify の開発者向け API でアプリケーションにメール検証の実装を開始しましょう。BillionVerify にサインアップして、無料の検証クレジットと包括的なドキュメントを入手してください。