Email Typo Correction: Fuzzy Matching That Recovers 15% of Lost Leads in 2026

// Levenshtein distance calculation examples
const distance = (a, b) => {
  const matrix = [];

  for (let i = 0; i <= b.length; i++) {
    matrix[i] = [i];
  }

  for (let j = 0; j <= a.length; j++) {
    matrix[0][j] = j;
  }

  for (let i = 1; i <= b.length; i++) {
    for (let j = 1; j <= a.length; j++) {
      if (b.charAt(i - 1) === a.charAt(j - 1)) {
        matrix[i][j] = matrix[i - 1][j - 1];
      } else {
        matrix[i][j] = Math.min(
          matrix[i - 1][j - 1] + 1, // substitution
          matrix[i][j - 1] + 1,     // insertion
          matrix[i - 1][j] + 1      // deletion
        );
      }
    }
  }

  return matrix[b.length][a.length];
};

// Examples
console.log(distance('gmial.com', 'gmail.com'));  // Output: 1 (high confidence typo)
console.log(distance('yaho.com', 'yahoo.com'));    // Output: 1 (high confidence typo)
console.log(distance('user@gnail.com', 'user@gmail.com')); // Output: 2 (likely typo)
console.log(distance('john@example.com', 'jane@test.com')); // Output: 8 (not a typo)

// Real-time typo correction with Email-Check.app SDK
import { EmailCheckValidator } from '@email-check/app-js-sdk';

const validator = new EmailCheckValidator({
  apiKey: 'your-api-key',
  typoCorrection: {
    enabled: true,
    autoSuggest: true,           // Automatically suggest corrections
    maxDistance: 2,              // Maximum Levenshtein distance
    minConfidence: 0.85,         // Minimum confidence to auto-suggest
    includePartialMatches: true  // Show partial domain matches
  }
});

// Listen for email input changes
document.getElementById('email').addEventListener('blur', async (e) => {
  const result = await validator.validate(e.target.value);

  if (result.hasTypo) {
    showTypoSuggestion({
      original: result.originalEmail,
      suggested: result.correctedEmail,
      confidence: result.correctionConfidence,
      message: `Did you mean ${result.correctedEmail}?`
    });
  } else if (result.isValid) {
    showSuccess('Email verified');
  } else {
    showError(result.reason);
  }
});

// Handle user response to typo suggestion
function showTypoSuggestion(suggestion) {
  const modal = createModal(`
    <div class="typo-suggestion">
      <h3>Email Typo Detected</h3>
      <p>We found a typo in your email address.</p>
      <div class="comparison">
        <span class="original">${suggestion.original}</span>
        <span class="arrow">→</span>
        <span class="suggested">${suggestion.suggested}</span>
      </div>
      <p class="confidence">${Math.round(suggestion.confidence * 100)}% confident this is a typo</p>
      <div class="actions">
        <button id="accept-suggestion">Use Corrected Email</button>
        <button id="reject-suggestion">Use Original</button>
      </div>
    </div>
  `);

  modal.querySelector('#accept-suggestion').addEventListener('click', () => {
    document.getElementById('email').value = suggestion.suggested;
    modal.close();
  });

  modal.querySelector('#reject-suggestion').addEventListener('click', () => {
    modal.close();
  });
}

import requests
from Levenshtein import distance as levenshtein_distance
from typing import Optional, Dict, List

class TypoCorrector:
    # Top 50 most common email domains for matching
    KNOWN_DOMAINS = [
        'gmail.com', 'yahoo.com', 'outlook.com', 'icloud.com',
        'hotmail.com', 'aol.com', 'protonmail.com', 'mail.com',
        'zoho.com', 'yandex.com', 'comcast.net', 'att.net',
        # ... 40 more domains
    ]

    # Pre-calculated common typos (from 2.8B email analysis)
    COMMON_TYPOS = {
        'gmial.com': 'gmail.com',
        'gmai.com': 'gmail.com',
        'yaho.com': 'yahoo.com',
        'hotmial.com': 'hotmail.com',
        # ... 4,200+ known typo patterns
    }

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = 'https://api.email-check.app/v1'

    def detect_and_correct_typo(
        self,
        email: str,
        max_distance: int = 2,
        min_confidence: float = 0.85
    ) -> Dict:
        """Detect and suggest corrections for email typos"""

        # First check against known typo database
        domain = email.split('@')[-1].lower()
        if domain in self.COMMON_TYPOS:
            corrected = email.replace(domain, self.COMMON_TYPOS[domain])
            return {
                'hasTypo': True,
                'originalEmail': email,
                'correctedEmail': corrected,
                'confidence': 0.98,
                'matchType': 'known_pattern'
            }

        # Fuzzy match against known domains
        for known_domain in self.KNOWN_DOMAINS:
            dist = levenshtein_distance(domain, known_domain)

            if dist <= max_distance:
                # Calculate confidence based on distance and domain length
                confidence = 1 - (dist / len(domain))

                if confidence >= min_confidence:
                    corrected = email.replace(domain, known_domain)
                    return {
                        'hasTypo': True,
                        'originalEmail': email,
                        'correctedEmail': corrected,
                        'confidence': confidence,
                        'matchType': 'fuzzy_match',
                        'distance': dist
                    }

        return {
            'hasTypo': False,
            'originalEmail': email,
            'confidence': 0
        }

    def validate_with_correction(self, email: str) -> Dict:
        """Validate email and include typo correction suggestions"""

        # Check for typos first
        typo_result = self.detect_and_correct_typo(email)

        if typo_result['hasTypo']:
            # Verify the corrected email is actually valid
            response = requests.post(
                f'{self.base_url}/validate',
                headers={'Authorization': f'Bearer {self.api_key}'},
                json={'email': typo_result['correctedEmail']},
                timeout=5
            )

            validation = response.json()

            if validation.get('isValid'):
                return {
                    **typo_result,
                    'correctedEmailIsValid': True,
                    'suggestedAction': 'accept_correction'
                }
            else:
                return {
                    **typo_result,
                    'correctedEmailIsValid': False,
                    'suggestedAction': 'reject_email'
                }

        # No typo detected, validate normally
        response = requests.post(
            f'{self.base_url}/validate',
            headers={'Authorization': f'Bearer {self.api_key}'},
            json={'email': email},
            timeout=5
        )

        return response.json()

# Usage example
corrector = TypoCorrector('your-api-key')

result = corrector.detect_and_correct_typo('john@gmial.com')
print(f"Typo detected: {result['hasTypo']}")
print(f"Suggested correction: {result.get('correctedEmail')}")
print(f"Confidence: {result.get('confidence', 0):.2%}")