Email Verification Pipelines for RevOps

The Data Quality Problem RevOps Owns

Leads enter your CRM from multiple channels: website forms, paid ads, events, SDR outreach, and partner referrals. Each source introduces bad email data at different rates. Web forms see disposable email signups at 3-5% of submissions. Event lead lists often contain 8-15% invalid contacts. Purchased lists can hit 25%+ undeliverable rates.

Once bad emails land in the CRM, they contaminate downstream processes. Marketing automation sends to undeliverable addresses. SDRs call contacts that bounce. Lead scoring models treat a disposable email the same as a corporate email, inflating MQL counts and distorting pipeline forecasts.

Verification pipelines fix this at the point of entry and on a continuous schedule.

Pipeline 1: Lead Scoring Integration

Most lead scoring models weight email quality implicitly (corporate domain = good, free domain = lower). That binary signal misses important nuances. An email from a valid corporate domain with a 95+ risk score is worth more than one from a corporate domain that fails SMTP verification. A free email from Gmail that passes SMTP checks might be a legitimate prospect.

The email-check.app API returns a score field (0-100) alongside boolean checks for SMTP, MX, disposable status, and role-based detection. Feed these fields into your scoring model instead of guessing from the domain alone.

Implementation Workflow

1. Intercept at entry: When a new lead enters the CRM (via form, API, or import), call the verification API before the record is saved.
2. Map API fields to scoring dimensions:score becomes the email quality signal. isDisposable becomes a disqualification flag. validSmtp confirms deliverability.isFree segments free vs. corporate email.
3. Update lead grade:Adjust the composite lead score based on verification results. A lead from a corporate domain with a 95+ score and confirmed SMTP stays at full grade. A lead from a disposable domain drops to a "Do Not Contact" status.
4. Route by segment: High-scoring leads route to SDR outreach. Medium-scoring leads enter nurturing. Low-scoring or disposable leads go to a review queue or suppression list.

// Lead scoring integration example (TypeScript)
async function scoreAndRouteLead(email: string, leadData: LeadInput) {
  const response = await fetch(
    `https://api.email-check.app/v1-get-email-details?email=${encodeURIComponent(email)}&verifyMx=true&verifySmtp=true&checkDomainAge=true&detectName=true`,
    { headers: { 'x-api-key': process.env.EC_API_KEY! } }
  );
  const result = await response.json();

  // Map verification data to scoring dimensions
  const emailQuality = {
    score: result.score,                    // 0-100 composite
    isDeliverable: result.validSmtp,        // SMTP confirmed
    isDisposable: result.isDisposable,      // temp/fake domain
    isRoleBased: false,                     // derived from prefix check
    isCorporate: !result.isFree,            // company domain
    domainAgeYears: result.domainAge?.ageInYears ?? 0,
    detectedName: result.detectedName,      // extracted first/last
  };

  // Scoring logic
  let leadGrade = 'C';  // default
  if (emailQuality.isDisposable) {
    leadGrade = 'SUPPRESS';  // do not contact
  } else if (emailQuality.isDeliverable && emailQuality.score >= 80 && emailQuality.isCorporate) {
    leadGrade = 'A';  // high-priority SDR outreach
  } else if (emailQuality.isDeliverable && emailQuality.score >= 50) {
    leadGrade = 'B';  // nurture track
  }
  // else remains 'C' — low priority or unverified

  return { ...leadData, emailQuality, leadGrade };
}

Pipeline 2: Automated CRM Hygiene

Email lists decay at roughly 22.5% per year. Contacts change jobs, domains expire, and inboxes fill up. A CRM that was clean six months ago is now 11% invalid. Without continuous verification, that decay compounds into hard bounces, sender reputation damage, and wasted campaign spend.

An automated CRM hygiene pipeline runs on a schedule, pulls contacts from the CRM, validates emails through the API, and updates records with verification status. This can run via n8n, Make, Zapier, or a custom cron job.

Implementation Workflow

1. Define the scope: Pull all contacts updated in the last 30 days, or contacts not verified in the last 90 days. Start with recently active contacts rather than re-validating the entire database in one run.
2. Batch the API calls: The email-check.app API validates one email per request. Process contacts in parallel batches of 10-50 concurrent requests with rate limiting. A typical 50K contact hygiene run completes in under 30 minutes at 25ms per request.
3. Tag contacts by verification status: Update CRM custom fields:email_validated (boolean), email_score (0-100),email_risk_tier (low/medium/high), email_last_checked (date).
4. Create suppression rules: Contacts with isDisposable = trueor validSmtp = false are automatically excluded from email campaigns. Contacts with score < 40 are flagged for review.
5. Schedule recurring runs: Weekly for high-velocity databases, monthly for smaller lists. Use webhook notifications (available on Growth plan and above) to get alerts when batch jobs complete.

// CRM hygiene batch processing (TypeScript)
const BATCH_SIZE = 25;  // concurrent requests
const DELAY_MS = 100;   // rate limit buffer

async function hydrateCRMContacts(contacts: Contact[]) {
  const results = [];

  for (let i = 0; i < contacts.length; i += BATCH_SIZE) {
    const batch = contacts.slice(i, i + BATCH_SIZE);

    const batchResults = await Promise.allSettled(
      batch.map(async (contact) => {
        const url = new URL('https://api.email-check.app/v1-get-email-details');
        url.searchParams.set('email', contact.email);
        url.searchParams.set('verifyMx', 'true');
        url.searchParams.set('verifySmtp', 'true');
        url.searchParams.set('suggestDomain', 'true');

        const res = await fetch(url.toString(), {
          headers: { 'x-api-key': process.env.EC_API_KEY! },
        });

        if (!res.ok) throw new Error(`HTTP ${res.status}`);
        const data = await res.json();

        return {
          contactId: contact.id,
          email: contact.email,
          score: data.score,
          isDeliverable: data.validSmtp,
          isDisposable: data.isDisposable,
          riskTier: data.score >= 80 ? 'low' : data.score >= 50 ? 'medium' : 'high',
          domainSuggestion: data.domainSuggestion,
        };
      })
    );

    results.push(...batchResults);
    if (i + BATCH_SIZE < contacts.length) {
      await new Promise(r => setTimeout(r, DELAY_MS));
    }
  }

  // Batch update CRM with results
  return updateCRMRecords(results);
}

Pipeline 3: Pre-Campaign Data Quality Gates

Before every email campaign, the send list should pass through a data quality gate. This pipeline validates the list, removes undeliverable addresses, corrects typos, and generates a quality report. Only contacts that pass the gate enter the campaign send queue.

This workflow integrates with marketing automation tools (HubSpot, Marketo, Mailchimp) via webhook triggers, API calls, or CSV-based workflows.

Implementation Workflow

1. Export or query the campaign list from your marketing automation platform.
2. Validate every email through the API with SMTP verification enabled. Enable suggestDomain to auto-correct typos.
3. Apply quality rules: Remove contacts where validSmtp = falseor isDisposable = true. For contacts with typo corrections (domainSuggestionis not null), apply the correction and re-validate.
4. Generate a quality report: Total contacts, valid, invalid, corrected, disposable, and risk distribution. Share this with campaign stakeholders before the send.
5. Upload the clean list back to the marketing automation platform or pass it directly via API.

// Pre-campaign quality gate (cURL + jq)
# Step 1: Validate single email with full checks
curl -s "https://api.email-check.app/v1-get-email-details?email=jon.doe@gnail.com&verifyMx=true&verifySmtp=true&suggestDomain=true"   -H "x-api-key: YOUR_API_KEY" | jq '.'

# Response with typo detected:
# {
#   "email": "jon.doe@gnail.com",
#   "validFormat": true,
#   "validMx": false,
#   "validSmtp": false,
#   "isDisposable": false,
#   "score": 5,
#   "domainSuggestion": {
#     "domain": "gmail.com",
#     "fullEmail": "jon.doe@gmail.com"
#   }
# }

# Step 2: Re-validate with corrected domain
curl -s "https://api.email-check.app/v1-get-email-details?email=jon.doe@gmail.com&verifyMx=true&verifySmtp=true"   -H "x-api-key: YOUR_API_KEY" | jq '.score'
# Output: 92

AI Agent and MCP Integration

AI agents running RevOps workflows can use email verification as a tool. Whether the agent is enriching leads, scoring prospects, or screening campaign lists, the email-check.app API works as a standard HTTP tool call.

For agents using MCP (Model Context Protocol), the email-check.app API can be wrapped as an MCP tool that agents invoke during lead enrichment or data quality workflows. The agent receives structured verification data and uses it to make routing decisions without human intervention.

// AI agent tool definition for email verification
const emailVerificationTool = {
  name: "verify_email",
  description: "Validate an email address. Returns deliverability status, " +
    "disposable detection, risk score, typo corrections, and domain intelligence.",
  inputSchema: {
    type: "object",
    properties: {
      email: { type: "string", format: "email", description: "Email to verify" },
      verify_smtp: { type: "boolean", default: true, description: "Check SMTP mailbox" },
      check_domain_age: { type: "boolean", default: false, description: "Get domain age" },
      suggest_domain: { type: "boolean", default: true, description: "Suggest typo corrections" },
    },
    required: ["email"],
  },
  handler: async ({ email, verify_smtp, check_domain_age, suggest_domain }) => {
    const params = new URLSearchParams({ email });
    if (verify_smtp) params.set("verifySmtp", "true");
    if (check_domain_age) params.set("checkDomainAge", "true");
    if (suggest_domain) params.set("suggestDomain", "true");

    const res = await fetch(
      `https://api.email-check.app/v1-get-email-details?${params}`,
      { headers: { "x-api-key": process.env.EC_API_KEY } }
    );
    return res.json();
  }
};

Pipeline Comparison

Frequently Asked Questions

How often should CRM hygiene run?

For databases with more than 50K contacts, weekly is recommended. For smaller databases, monthly is sufficient. The frequency depends on how fast contacts enter and leave your system. High-velocity SaaS products with daily signups should validate on entry (real-time) and run weekly hygiene checks.

Does this work with Salesforce, HubSpot, and Pipedrive?

Yes. The email-check.app API is a standard REST endpoint. For Salesforce, use an Apex trigger or Flow to call the API on record creation. For HubSpot, use a workflow automation or custom code action. For Pipedrive, use webhooks or the API. All three CRMs support custom fields for storing validation data like risk score and verification status.

How do I handle bulk validation at scale?

The API validates one email per request with 25ms average response. For bulk processing, use parallel requests with batching. Process 10-50 emails concurrently with a small delay between batches. A 100K-contact hygiene run completes in approximately 15-20 minutes with this approach. For larger volumes, contact the team about dedicated infrastructure options.

Can AI agents use this for autonomous workflows?

Yes. The API works as a standard HTTP tool for AI agents using Claude, GPT, or custom agent frameworks. Agents can call the verification endpoint during lead enrichment, prospecting, or data quality workflows. For MCP-based setups, the API can be wrapped as an MCP tool that agents invoke directly.