Integration Guide

MCP Client Setup

Add the Email Address Validator MCP server to your MCP client configuration:

{
  "mcpServers": {
    "email-validator": {
      "command": "curl",
      "args": [
        "-X", "POST",
        "https://apistack.online/api/mcp/utilities/email-address-validator/sse",
        "-H", "Content-Type: application/json",
        "-H", "Authorization: Bearer YOUR_API_KEY",
        "--data-raw", "@-"
      ],
      "transport": "sse"
    }
  }
}

Authentication

Ensure your API key has PRO or ENTERPRISE plan access:

export MCP_EMAIL_VALIDATOR_API_KEY="your-api-key"

Usage Examples

Basic Email Validation

const result = await mcpClient.callTool('validate_email', {
  email: 'user@example.com',
  validationType: 'comprehensive'
});

Bulk Validation

const result = await mcpClient.callTool('validate_emails_bulk', {
  emails: ['user1@gmail.com', 'user2@company.com', 'temp@mailinator.com'],
  checkDisposable: true
});

Quick Syntax Check

const result = await mcpClient.callTool('check_email_syntax', {
  email: 'user@domain.com'
});

Typo Suggestion

const result = await mcpClient.callTool('suggest_email_correction', {
  email: 'user@gmai.com'
});

Error Handling

The server returns comprehensive error messages:

try {
  const result = await mcpClient.callTool('validate_email', {
    email: 'invalid-email'
  });
} catch (error) {
  console.error('Validation failed:', error.message);
}

Best Practices

1. Use appropriate validation types:

   • syntax for quick checks
   • domain for deliverability
   • comprehensive for security

2. Batch processing: Use validate_emails_bulk for multiple emails

3. Cache results: Store validation results to reduce API calls

4. Handle typos: Use suggest_email_correction for user-friendly error messages

5. Risk-based workflows: Implement different flows based on risk scores:

   • 0-20: Auto-approve
   • 21-50: Additional verification
   • 51-80: Manual review
   • 81-100: Reject

Email Address Validator MCP Server

Overview

The Email Address Validator MCP server provides comprehensive email validation and verification functionality through the Model Context Protocol (MCP). This server wraps our battle-tested Email Address Validator API to provide AI agents with professional email validation capabilities.

🔧 Exposed Tools

This MCP server exposes 5 tools for AI agents:

1. validate_email

Purpose: Comprehensive email address validation with all security and quality checks

• Input:
  • email (string, required) - Email address to validate (max 254 characters)
  • validationType (string, optional) - Type: "syntax", "domain", or "comprehensive" (default)
  • checkMX (boolean, optional) - Check domain MX records (default: true)
  • checkDisposable (boolean, optional) - Check for disposable email providers (default: true)
  • checkFreeProvider (boolean, optional) - Check for free email providers (default: true)
  • checkRoleAccount (boolean, optional) - Check for role-based accounts (default: true)
  • suggestTypos (boolean, optional) - Suggest typo corrections (default: true)
  • includeRiskScore (boolean, optional) - Include risk score 0-100 (default: true)
• Output: Comprehensive validation results with syntax analysis, MX records, disposable detection, risk scoring
• Example: "user@gmail.com" → Valid, Low Risk (Score: 15), Free Provider

2. validate_emails_bulk

Purpose: Validate multiple email addresses in a single request (up to 100 emails)

• Input:
  • emails (array, required) - Array of 1-100 email addresses to validate
  • All optional parameters from validate_email
• Output: Array of validation results for each email
• Use case: Clean email lists, validate imports, batch verification
• Example: Validate 50 emails → 42 valid, 5 disposable, 3 invalid

3. check_email_syntax

Purpose: Quick RFC 5322 compliant syntax-only validation (fastest method)

• Input: email (string, required) - Email address to check
• Output: Boolean valid/invalid with syntax issues if any
• Performance: Ultra-fast (< 5ms), no external dependencies
• Use case: Real-time form validation, quick checks
• Example: "user@domain.com" ✓ Valid | "user@.domain.com" ✗ Invalid

4. check_domain_mx

Purpose: Check if a domain has valid MX records for email delivery

• Input: domain (string, required) - Domain name to check (max 253 characters)
• Output: MX record count, validity status, mail server details
• Use case: Verify email deliverability, domain validation
• Example: "gmail.com" → Valid, 5 MX records

5. suggest_email_correction

Purpose: Suggest corrections for emails with potential domain typos

• Input: email (string, required) - Email address to analyze
• Output: Suggested correction with confidence level
• Use case: Help users fix typos, improve data quality
• Example: "user@gmai.com" → Suggestion: "gmail.com" (High confidence)

🔗 Server Details

• Category: Utilities
• Transport: Server-Sent Events (SSE)
• Endpoint: /api/mcp/utilities/email-address-validator/sse
• Authentication: Required (PRO/ENTERPRISE plans only)
• Wrapped API: /api/utilities/email-address-validator/v1
• Rate Limits: 60 requests/minute, 1000 requests/hour, 100 emails per bulk request

📋 Prerequisites

• Subscription: PRO or ENTERPRISE plan
• API Key: Valid API key with Email Validator access
• MCP Client: Any MCP-compatible client or AI agent

🚀 Quick Start

Connection Setup

Endpoint: https://apistack.online/api/mcp/utilities/email-address-validator/sse
Method: POST
Headers:
  Content-Type: application/json
  Authorization: Bearer YOUR_API_KEY

Basic MCP Requests

List Available Tools

{
  "jsonrpc": "2.0",
  "id": "list-tools",
  "method": "tools/list"
}

Validate Single Email

{
  "jsonrpc": "2.0",
  "id": "validate-1",
  "method": "tools/call",
  "params": {
    "name": "validate_email",
    "arguments": {
      "email": "user@example.com",
      "validationType": "comprehensive",
      "includeRiskScore": true
    }
  }
}

Bulk Validate Emails

{
  "jsonrpc": "2.0",
  "id": "bulk-1",
  "method": "tools/call",
  "params": {
    "name": "validate_emails_bulk",
    "arguments": {
      "emails": ["user1@gmail.com", "admin@company.com", "temp@10minutemail.com"],
      "checkDisposable": true,
      "includeRiskScore": true
    }
  }
}

Quick Syntax Check

{
  "jsonrpc": "2.0",
  "id": "syntax-1",
  "method": "tools/call",
  "params": {
    "name": "check_email_syntax",
    "arguments": {
      "email": "user@domain.com"
    }
  }
}

💻 Implementation Examples

Python Example

import requests
import json

class EmailValidatorMCPClient:
    def __init__(self, base_url, api_key):
        self.base_url = base_url
        self.headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {api_key}"
        }
        self.endpoint = f"{base_url}/api/mcp/utilities/email-address-validator/sse"
    
    def validate_email(self, email, validation_type="comprehensive", include_risk_score=True):
        request = {
            "jsonrpc": "2.0",
            "id": "validate",
            "method": "tools/call",
            "params": {
                "name": "validate_email",
                "arguments": {
                    "email": email,
                    "validationType": validation_type,
                    "includeRiskScore": include_risk_score
                }
            }
        }
        
        response = requests.post(self.endpoint, headers=self.headers, json=request)
        result = response.json()
        return result["result"]
    
    def validate_bulk(self, emails, check_disposable=True):
        request = {
            "jsonrpc": "2.0",
            "id": "bulk",
            "method": "tools/call",
            "params": {
                "name": "validate_emails_bulk",
                "arguments": {
                    "emails": emails,
                    "checkDisposable": check_disposable,
                    "includeRiskScore": True
                }
            }
        }
        
        response = requests.post(self.endpoint, headers=self.headers, json=request)
        result = response.json()
        return result["result"]
    
    def check_syntax(self, email):
        request = {
            "jsonrpc": "2.0",
            "id": "syntax",
            "method": "tools/call",
            "params": {
                "name": "check_email_syntax",
                "arguments": {"email": email}
            }
        }
        
        response = requests.post(self.endpoint, headers=self.headers, json=request)
        result = response.json()
        return result["result"]
    
    def suggest_correction(self, email):
        request = {
            "jsonrpc": "2.0",
            "id": "suggest",
            "method": "tools/call",
            "params": {
                "name": "suggest_email_correction",
                "arguments": {"email": email}
            }
        }
        
        response = requests.post(self.endpoint, headers=self.headers, json=request)
        result = response.json()
        return result["result"]

# Usage
client = EmailValidatorMCPClient("https://apistack.online", "YOUR_API_KEY")

# Validate single email
result = client.validate_email("user@example.com")
print(f"Valid: {result['isValid']}, Risk Score: {result['riskScore']['score']}")

# Bulk validation
emails_to_check = ["user1@gmail.com", "temp@10minutemail.com", "admin@company.com"]
bulk_results = client.validate_bulk(emails_to_check)
print(f"Validated {len(bulk_results['results'])} emails")

# Quick syntax check
syntax_result = client.check_syntax("user@domain.com")
print(f"Syntax Valid: {syntax_result['isValid']}")

# Get typo suggestion
suggestion = client.suggest_correction("user@gmai.com")
if suggestion['hasSuggestion']:
    print(f"Did you mean: {suggestion['suggestion']}?")

JavaScript/Node.js Example

const axios = require('axios');

class EmailValidatorMCPClient {
    constructor(baseUrl, apiKey) {
        this.baseUrl = baseUrl;
        this.endpoint = `${baseUrl}/api/mcp/utilities/email-address-validator/sse`;
        this.headers = {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${apiKey}`
        };
    }

    async validateEmail(email, validationType = 'comprehensive', includeRiskScore = true) {
        const request = {
            jsonrpc: "2.0",
            id: "validate",
            method: "tools/call",
            params: {
                name: "validate_email",
                arguments: {
                    email,
                    validationType,
                    includeRiskScore
                }
            }
        };

        const response = await axios.post(this.endpoint, request, { headers: this.headers });
        return response.data.result;
    }

    async validateBulk(emails, checkDisposable = true) {
        const request = {
            jsonrpc: "2.0",
            id: "bulk",
            method: "tools/call",
            params: {
                name: "validate_emails_bulk",
                arguments: {
                    emails,
                    checkDisposable,
                    includeRiskScore: true
                }
            }
        };

        const response = await axios.post(this.endpoint, request, { headers: this.headers });
        return response.data.result;
    }

    async checkSyntax(email) {
        const request = {
            jsonrpc: "2.0",
            id: "syntax",
            method: "tools/call",
            params: {
                name: "check_email_syntax",
                arguments: { email }
            }
        };

        const response = await axios.post(this.endpoint, request, { headers: this.headers });
        return response.data.result;
    }

    async suggestCorrection(email) {
        const request = {
            jsonrpc: "2.0",
            id: "suggest",
            method: "tools/call",
            params: {
                name: "suggest_email_correction",
                arguments: { email }
            }
        };

        const response = await axios.post(this.endpoint, request, { headers: this.headers });
        return response.data.result;
    }
}

// Usage
(async () => {
    const client = new EmailValidatorMCPClient("https://apistack.online", "YOUR_API_KEY");
    
    // Validate single email
    const result = await client.validateEmail("user@example.com");
    console.log(`Valid: ${result.isValid}, Risk: ${result.riskScore.score}`);
    
    // Bulk validation
    const emails = ["user1@gmail.com", "temp@10minutemail.com", "admin@company.com"];
    const bulkResults = await client.validateBulk(emails);
    console.log(`Validated ${bulkResults.results.length} emails`);
    
    // Quick syntax check
    const syntaxResult = await client.checkSyntax("user@domain.com");
    console.log(`Syntax Valid: ${syntaxResult.isValid}`);
    
    // Typo suggestion
    const suggestion = await client.suggestCorrection("user@gmai.com");
    if (suggestion.hasSuggestion) {
        console.log(`Did you mean: ${suggestion.suggestion}?`);
    }
})();

cURL Examples

# List available tools
curl -X POST "https://apistack.online/api/mcp/utilities/email-address-validator/sse" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "jsonrpc": "2.0",
    "id": "list-tools",
    "method": "tools/list"
  }'

# Validate single email
curl -X POST "https://apistack.online/api/mcp/utilities/email-address-validator/sse" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "jsonrpc": "2.0",
    "id": "validate",
    "method": "tools/call",
    "params": {
      "name": "validate_email",
      "arguments": {
        "email": "user@example.com",
        "validationType": "comprehensive",
        "includeRiskScore": true
      }
    }
  }'

# Bulk validate
curl -X POST "https://apistack.online/api/mcp/utilities/email-address-validator/sse" \
  -H "Content-Type": "application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "jsonrpc": "2.0",
    "id": "bulk",
    "method": "tools/call",
    "params": {
      "name": "validate_emails_bulk",
      "arguments": {
        "emails": ["user1@gmail.com", "temp@10minutemail.com", "admin@company.com"],
        "checkDisposable": true
      }
    }
  }'

# Quick syntax check
curl -X POST "https://apistack.online/api/mcp/utilities/email-address-validator/sse" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "jsonrpc": "2.0",
    "id": "syntax",
    "method": "tools/call",
    "params": {
      "name": "check_email_syntax",
      "arguments": {
        "email": "user@domain.com"
      }
    }
  }'

🔒 Security & Authentication

• Authentication Required: All requests must include a valid Bearer token
• Plan Access: PRO and ENTERPRISE plans only
• Rate Limiting: 60 requests/minute, 1000 requests/hour
• Input Validation: All emails validated for format and RFC 5322 compliance
• Error Handling: Comprehensive error responses following MCP protocol
• Data Privacy: No email addresses are stored or logged

📊 Response Format

All tool responses follow the MCP protocol format:

Success Response (validate_email)

{
  "jsonrpc": "2.0",
  "id": "validate",
  "result": {
    "content": [{
      "type": "text",
      "text": "📧 Email: user@example.com\n✅ Valid: YES\n🔤 Syntax: Valid\n🌐 MX Records: Valid (1 records)\n🚫 Disposable: NO\n📧 Free Provider: NO\n👤 Role Account: NO\n⚠️ Risk Score: 5/100 (low)"
    }],
    "isError": false
  }
}

Success Response (validate_emails_bulk)

{
  "jsonrpc": "2.0",
  "id": "bulk",
  "result": {
    "content": [{
      "type": "text",
      "text": "📊 Bulk Validation Results:\n\nTotal Emails: 3\n✅ Valid: 2\n❌ Invalid: 1\n🚫 Disposable: 1\n⚠️ High Risk: 1"
    }],
    "isError": false
  }
}

Error Response

{
  "jsonrpc": "2.0",
  "id": "request-id",
  "error": {
    "code": -32603,
    "message": "Email address is required and must be a string"
  }
}

🧪 Testing

You can test the MCP server using the provided cURL examples above or create a simple test script.

🏗️ Architecture

AI Agent/Client
       ↓
MCP Protocol (JSON-RPC 2.0)
       ↓
Email Validator MCP Server (/api/mcp/utilities/email-address-validator/sse)
       ↓
Authentication & Validation
       ↓
Email Validator API (/api/utilities/email-address-validator/v1)
       ↓
- RFC 5322 Syntax Validation
- DNS MX Record Lookup
- Disposable Email Detection (Dynamic GitHub sources)
- Risk Scoring Engine
- Typo Suggestion Algorithm
       ↓
Response via MCP Protocol

📝 Tool Schemas

validate_email Schema

{
  "name": "validate_email",
  "description": "Comprehensive email validation with syntax, MX, disposable detection, and risk scoring",
  "inputSchema": {
    "type": "object",
    "properties": {
      "email": {
        "type": "string",
        "maxLength": 254,
        "description": "Email address to validate"
      },
      "validationType": {
        "type": "string",
        "enum": ["syntax", "domain", "comprehensive"],
        "default": "comprehensive"
      },
      "checkMX": {"type": "boolean", "default": true},
      "checkDisposable": {"type": "boolean", "default": true},
      "checkFreeProvider": {"type": "boolean", "default": true},
      "checkRoleAccount": {"type": "boolean", "default": true},
      "suggestTypos": {"type": "boolean", "default": true},
      "includeRiskScore": {"type": "boolean", "default": true}
    },
    "required": ["email"]
  }
}

validate_emails_bulk Schema

{
  "name": "validate_emails_bulk",
  "description": "Validate multiple emails in bulk (up to 100)",
  "inputSchema": {
    "type": "object",
    "properties": {
      "emails": {
        "type": "array",
        "items": {"type": "string", "maxLength": 254},
        "minItems": 1,
        "maxItems": 100
      },
      "checkMX": {"type": "boolean", "default": true},
      "checkDisposable": {"type": "boolean", "default": true},
      "checkFreeProvider": {"type": "boolean", "default": true},
      "checkRoleAccount": {"type": "boolean", "default": true},
      "suggestTypos": {"type": "boolean", "default": true},
      "includeRiskScore": {"type": "boolean", "default": true}
    },
    "required": ["emails"]
  }
}

check_email_syntax Schema

{
  "name": "check_email_syntax",
  "description": "Quick RFC 5322 syntax validation only",
  "inputSchema": {
    "type": "object",
    "properties": {
      "email": {
        "type": "string",
        "maxLength": 254,
        "description": "Email to check syntax"
      }
    },
    "required": ["email"]
  }
}

check_domain_mx Schema

{
  "name": "check_domain_mx",
  "description": "Check domain MX records for email delivery capability",
  "inputSchema": {
    "type": "object",
    "properties": {
      "domain": {
        "type": "string",
        "maxLength": 253,
        "description": "Domain to check MX records"
      }
    },
    "required": ["domain"]
  }
}

suggest_email_correction Schema

{
  "name": "suggest_email_correction",
  "description": "Suggest corrections for email typos",
  "inputSchema": {
    "type": "object",
    "properties": {
      "email": {
        "type": "string",
        "maxLength": 254,
        "description": "Email to analyze for typos"
      }
    },
    "required": ["email"]
  }
}

🎯 Use Cases

User Registration

• Validate emails during signup to ensure deliverability
• Prevent fake accounts with disposable email detection
• Reduce bounce rates and improve data quality
• Example: Block temp@10minutemail.com, allow john@company.com

Email Marketing

• Clean email lists before campaigns
• Remove disposable and invalid addresses
• Improve deliverability and sender reputation
• Example: Bulk validate 5,000 emails → Remove 250 bad addresses

Lead Quality Assessment

• Score leads based on email quality
• Identify business vs free email providers
• Flag role-based accounts for special handling
• Example: john@acme.com (Business, Score: 5) vs user123@gmail.com (Free, Score: 25)

Fraud Prevention

• Detect disposable email patterns
• Identify high-risk email characteristics
• Implement risk-based verification flows
• Example: temp@mailinator.com → Risk Score: 95 (Critical)

Data Quality Improvement

• Suggest typo corrections during data entry
• Validate imported email lists
• Maintain clean customer databases
• Example: user@gmai.com → Suggest: gmail.com

Customer Onboarding

• Implement progressive validation flows
• Quick syntax checks for real-time feedback
• Comprehensive validation before account activation
• Example: Form validation → Syntax check → Full validation on submit

🤝 Support

For issues, feature requests, or integration help:

• Check the API documentation
• Review the examples above
• Test with the provided cURL commands
• Contact support for assistance

---

Note: This MCP server requires a PRO or ENTERPRISE subscription and valid API authentication. The server provides enterprise-grade email validation with dynamic data sources for disposable email detection and comprehensive risk assessment.

Available Tools

validate_email

Comprehensive email validation with all security and quality checks.

Input Parameters:

• email (string, required) - Email address to validate (max 254 characters)
• validationType (string, optional) - "syntax", "domain", or "comprehensive" (default)
• checkMX (boolean, optional) - Check domain MX records (default: true)
• checkDisposable (boolean, optional) - Check for disposable providers (default: true)
• checkFreeProvider (boolean, optional) - Check for free providers (default: true)
• checkRoleAccount (boolean, optional) - Check for role accounts (default: true)
• suggestTypos (boolean, optional) - Suggest typo corrections (default: true)
• includeRiskScore (boolean, optional) - Include risk score (default: true)

Example:

{
  "email": "user@example.com",
  "validationType": "comprehensive",
  "includeRiskScore": true
}

Output:

• Syntax validation results
• MX record status and count
• Disposable email detection
• Free provider identification
• Role account detection
• Risk score (0-100, lower is better)
• Typo suggestions if applicable

validate_emails_bulk

Validate multiple email addresses in bulk (up to 100 emails per request).

Input Parameters:

• emails (array, required) - Array of 1-100 email addresses
• All optional parameters from validate_email

Example:

{
  "emails": ["user1@gmail.com", "temp@10minutemail.com", "admin@company.com"],
  "checkDisposable": true,
  "includeRiskScore": true
}

Output:

• Array of validation results for each email
• Summary statistics (total, valid, invalid, disposable, high-risk)
• Individual risk scores and validation details

check_email_syntax

Quick RFC 5322 compliant syntax validation only (fastest method).

Input Parameters:

• email (string, required) - Email address to check

Example:

{
  "email": "user@domain.com"
}

Output:

• Boolean valid/invalid status
• Syntax issues if any
• Ultra-fast response (< 5ms)

check_domain_mx

Check if a domain has valid MX records for email delivery.

Input Parameters:

• domain (string, required) - Domain name to check (max 253 characters)

Example:

{
  "domain": "gmail.com"
}

Output:

• MX record validity
• Number of MX records
• Mail server details

suggest_email_correction

Suggest corrections for email addresses with potential typos.

Input Parameters:

• email (string, required) - Email address to analyze

Example:

{
  "email": "user@gmai.com"
}

Output:

• Suggested correction
• Confidence level (high/medium/low)
• Original vs corrected email