Email Deliverability: Keep Your Emails Out of Spam

Email deliverability is the percentage of emails that reach the recipient's inbox rather than bouncing or landing in spam. In 2026, inbox providers (Gmail, Outlook, Yahoo) have tightened their filtering algorithms significantly. Google alone updated its sender requirements in February 2024, mandating SPF/DKIM/DMARC authentication and requiring bulk senders to keep spam complaint rates below 0.1%.

The consequences of poor deliverability are severe:

• Bounce rates above 2% trigger spam filters and throttle your sending domain
• Spam complaints above 0.1% can get your domain permanently blocklisted
• Invalid email sends waste credits on cold email platforms (Instantly, Smartlead, Lemlist)
• Damaged sender reputation affects ALL emails from your domain, including transactional emails to customers

The root cause of most deliverability problems is sending to bad email addresses. Lists sourced from conferences, purchased databases, scraped directories, and even CRM exports contain 15 to 30% invalid addresses. Without validation, every send is a gamble.

Email Validation is the first line of defense. At 1 credit per validation ($0.0005 on the Growth Pack), it costs almost nothing and prevents the most common deliverability killer: high bounce rates.

Email validation verifies that an address exists and can receive mail. Enrich's Email Validation API performs multiple checks in sequence:

1. Syntax validation Checks that the email follows RFC 5322 format. Catches typos like user@gmial.com or user@@company.com.

2. DNS and MX record verification Looks up the domain's MX (mail exchange) records to confirm the domain exists and has a mail server configured. Domains without MX records cannot receive email.

3. SMTP verification Connects to the recipient's mail server and performs a simulated delivery (HELO, MAIL FROM, RCPT TO) without actually sending a message. The server responds with whether the mailbox exists. This is the most reliable check.

4. Catch-all detection Some domains accept mail for any address, even nonexistent ones. These "catch-all" configurations (common at large enterprises) make SMTP verification unreliable. The API flags these as "risky" so you can decide how to handle them.

5. Disposable email detection Identifies temporary email providers like Guerrilla Mail, Mailinator, Temp Mail, and 10MinuteMail. These are commonly used during signups to avoid real contact. For B2B outreach, these are always invalid targets.

6. Role-based address detection Flags generic addresses like info@, support@, sales@, admin@. These are often monitored by multiple people or filtered aggressively. Not ideal for personalized outreach.

• valid: The mailbox exists and can receive mail
• risky: Catch-all domain or unable to verify conclusively
• invalid: Mailbox does not exist, domain expired, or syntax error

Each verdict includes specific reason codes for programmatic handling.

Catch-all domains are one of the trickiest challenges in email deliverability. A catch-all domain accepts email sent to any address, whether the mailbox exists or not. This means SMTP verification always returns "accepted," giving you no way to distinguish real addresses from made-up ones.

• Large enterprises (Fortune 500 companies)
• Government agencies
• Universities and educational institutions
• Companies using legacy email systems

How Enrich handles catch-all domains:

The Email Validation API detects catch-all configurations and marks them as "risky" rather than "valid." This prevents false confidence. You get a clear signal: this address might work, but we cannot confirm it.

Best practices for catch-all addresses:

1. 1Do not discard them. Many catch-all addresses are real and active. Just treat them differently.
2. 2Send to catch-all addresses in separate campaigns. This isolates any bounce impact from your main sends.
3. 3Start with smaller batches. Send to 50 to 100 catch-all addresses first and monitor bounce rates.
4. 4Use engagement signals. If a catch-all address opens or clicks, promote it to your validated list.
5. 5Pair with Email Finder. If you have the person's name and company domain, use the Email Finder API to independently verify the address (10 credits). A match from Email Finder plus a catch-all validation means the address is almost certainly real.

Disposable email providers (Guerrilla Mail, Mailinator, Temp Mail, YOPmail, and hundreds of others) generate temporary inboxes that expire after minutes or hours. People use them to:

• Sign up for free trials without providing real contact info
• Download gated content without subscribing
• Avoid marketing follow-up

For B2B teams, disposable emails represent wasted effort. Every signup from a disposable address inflates your lead count, skews conversion metrics, and wastes enrichment credits if you try to look them up.

Real-time filtering with Enrich:

Integrate the Email Validation API into your signup forms to catch disposable emails at the point of capture:

import Enrich from '@enrich.so/sdk';
const enrich = new Enrich('YOUR_API_KEY');
async function validateSignupEmail(email: string) {
  const result = await enrich.emailValidation.verify({ email });
  if (result.disposable) {
    return {
      valid: false,
      message: 'Please use a work email address',
    };
  }
  if (result.status === 'invalid') {
    return {
      valid: false,
      message: 'This email address appears to be invalid',
    };
  }
  return { valid: true };
}

At 1 credit per validation, checking every signup costs negligible amounts. On the Growth Pack ($49/mo for 100K credits), you can validate 100,000 form submissions per month.

Enrich maintains a database of 10,000+ known disposable email domains and updates it continuously. The detection covers both well-known providers and obscure temporary email services.

Before running any cold email campaign, validate your entire list. Enrich's batch validation endpoint processes up to 500,000 emails in a single request.

Step 1: Submit your list

import Enrich from '@enrich.so/sdk';
const enrich = new Enrich('YOUR_API_KEY');
// Submit batch validation (up to 500K emails)
const batch = await enrich.emailValidation.batch({
  records: emailList.map(email => ({ email })),
  webhookUrl: 'https://your-app.com/webhooks/validation',
});
console.log(`Batch ${batch.batchId} submitted`);
console.log(`${batch.totalRecords} emails queued`);

Step 2: Receive results via webhook

Enrich sends webhook callbacks as results complete. You can receive per-result callbacks or wait for the entire batch:

app.post('/webhooks/validation', async (req, res) => {
  const { event, data } = req.body;
  if (event === 'validation.completed') {
    const valid = data.results.filter(r => r.status === 'valid');
    const risky = data.results.filter(r => r.status === 'risky');
    const invalid = data.results.filter(r => r.status === 'invalid');
    console.log(`Valid: ${valid.length}`);
    console.log(`Risky: ${risky.length}`);
    console.log(`Invalid: ${invalid.length}`);
    // Remove invalid from your campaign list
    await removeFromCampaign(invalid.map(r => r.email));
    // Move risky to separate campaign
    await moveToRiskyCampaign(risky.map(r => r.email));
  }
  res.status(200).send('OK');
});

Step 3: Segment and send

• Valid emails: Send in your primary campaign with confidence
• Risky emails (catch-all): Send in a separate campaign with lower volume and closer monitoring
• Invalid emails: Remove entirely. Do not send.

Auto-refund on failures: Enrich automatically refunds credits for lookups that fail due to server errors or timeouts. You only pay for successful validations.

Credit cost for list cleaning:

At these prices, there is no reason not to validate. The cost of validation is a fraction of the cost of a damaged sender reputation.

Most cold email platforms do not include robust email validation. Here is how to integrate Enrich validation with the three most popular tools.

Instantly

Instantly accepts CSV imports for campaign leads. The workflow:

1. 1Export your lead list as CSV
2. 2Upload to Enrich Data Tables at dash.enrich.so
3. 3Run Email Validation on the entire list (1 credit per email)
4. 4Download the enriched CSV with validation status column
5. 5Filter to "valid" only and import into Instantly
6. 6Create a separate Instantly campaign for "risky" (catch-all) leads with lower sending limits

Instantly charges per email account, not per lead. By removing invalid addresses before import, you avoid wasting sends and protect your domain reputation.

Smartlead

Smartlead supports API lead imports and webhook integrations:

1. 1Use the Enrich batch validation API to validate your list programmatically
2. 2Filter results to valid and risky
3. 3Push validated leads to Smartlead via their API
4. 4Smartlead's built-in email warm-up handles inbox placement; Enrich handles list quality

Smartlead auto-pauses campaigns with high bounce rates. Pre-validation with Enrich prevents those pauses.

Lemlist

Lemlist has a CSV import flow similar to Instantly:

1. 1Validate your list with Enrich (batch API or Data Tables)
2. 2Export the validated list (valid + risky segments)
3. 3Import into Lemlist
4. 4Use Lemlist's personalization features (dynamic images, custom variables) on clean data
5. 5Monitor bounce rates per campaign; re-validate before subsequent sends

For all three tools: Schedule monthly re-validation of your active lead lists. People change jobs, email addresses get deactivated, and domains expire. A list that was 95% valid three months ago may have decayed to 80% by the time you reuse it.

For teams building custom outreach systems or enrichment pipelines, here is a production-ready validation flow using the Enrich TypeScript SDK.

Install the SDK:

npm install @enrich.so/sdk

Complete validation pipeline:

import Enrich from '@enrich.so/sdk';
const enrich = new Enrich('YOUR_API_KEY');
interface ValidationResult {
  email: string;
  status: 'valid' | 'risky' | 'invalid';
  disposable: boolean;
  catchAll: boolean;
  reason: string;
}
async function validateEmailList(
  emails: string[]
): Promise<{
  valid: string[];
  risky: string[];
  invalid: string[];
  stats: { total: number; validRate: number };
}> {
  const results: ValidationResult[] = [];
  // For lists under 1,000, use single lookups
  if (emails.length < 1000) {
    for (const email of emails) {
      const result = await enrich.emailValidation.verify({ email });
      results.push({
        email,
        status: result.status,
        disposable: result.disposable,
        catchAll: result.catchAll,
        reason: result.reason,
      });
    }
  } else {
    // For larger lists, use batch API
    const batch = await enrich.emailValidation.batch({
      records: emails.map(email => ({ email })),
    });
    // Poll for completion
    let status = await enrich.emailValidation.batchStatus(batch.batchId);
    while (status.state !== 'completed') {
      await new Promise(resolve => setTimeout(resolve, 5000));
      status = await enrich.emailValidation.batchStatus(batch.batchId);
    }
    // Retrieve results
    const batchResults = await enrich.emailValidation.batchResults(
      batch.batchId
    );
    results.push(...batchResults.results);
  }
  const valid = results.filter(r => r.status === 'valid').map(r => r.email);
  const risky = results.filter(r => r.status === 'risky').map(r => r.email);
  const invalid = results.filter(r => r.status === 'invalid').map(r => r.email);
  return {
    valid,
    risky,
    invalid,
    stats: {
      total: emails.length,
      validRate: Math.round((valid.length / emails.length) * 100),
    },
  };
}
// Usage
const { valid, risky, invalid, stats } = await validateEmailList(myLeadList);
console.log(`Validation rate: ${stats.validRate}%`);
console.log(`${valid.length} valid, ${risky.length} risky, ${invalid.length} invalid`);

REST API alternative (cURL):

# Single validation
curl -X POST https://api.enrich.so/v1/email-validation \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "prospect@company.com"}'

Response:

{
  "email": "prospect@company.com",
  "status": "valid",
  "catchAll": false,
  "disposable": false,
  "reason": "mailbox_exists",
  "provider": "Google Workspace"
}

The Go SDK (github.com/maximiseai/enrich-go-sdk) provides the same functionality for backend services written in Go.

Before launching any cold email campaign, run through this checklist:

• SPF, DKIM, and DMARC records configured on your sending domain
• Separate sending domain from your primary business domain
• Email accounts warmed up for at least 2 weeks (use Instantly, Smartlead, or Warmbox)
• Sending volume ramped gradually (start with 20/day, increase by 10/day)

• All emails validated through Enrich Email Validation (1 credit each)
• Invalid addresses removed entirely
• Catch-all addresses segmented into a separate campaign
• Disposable and role-based addresses (info@, support@) removed
• Bounce rate target: under 2% per campaign

• Plain text or minimal HTML (no heavy images or attachments)
• Personalization tokens populated with enriched data (name, company, title)
• Unsubscribe link included in every email
• Sending volume kept under 50 emails per inbox per day
• Replies monitored within 24 hours

• Re-validate lists monthly before reuse
• Monitor bounce rates per campaign and per sending account
• Remove hard bounces immediately
• Pause sending if bounce rate exceeds 2% on any campaign
• Re-enrich contacts quarterly to catch job changes (use Reverse Email Lookup)

Email validation is the cheapest and highest-impact step on this list. At $0.0005 per validation, cleaning a 10,000-lead list costs $5 and can prevent thousands of dollars in deliverability damage.