Email Validator & Verifier Actor

Validate email addresses instantly with professional-grade verification that checks deliverability, identifies risky emails, and flags undeliverable addresses. Powered by advanced email verification API.

🚀 Features

• Bulk Validation: Validate multiple email addresses in one run
• Sequential Processing: Processes emails one by one for reliable results
• Three-Tier Classification:
  • ✅ Deliverable - Email is valid and can receive messages
  • ⚠️ Risky - Email may have issues (use with caution)
  • ❌ Undeliverable - Email is invalid or cannot receive messages
• Real-time Processing: Live updates as each email is validated
• Comprehensive Error Handling: Detailed error reporting for failed validations
• Structured Output: Clean, organized results in dataset format

📋 Input Parameters

Field	Type	Required	Description
emails	Array	Yes	List of email addresses to validate

Example Input

{
  "emails": [
    "john.doe@example.com",
    "jane.smith@company.com",
    "info@business.org",
    "invalid-email@test.com"
  ]
}

📤 Output Format

Each validated email produces a detailed record in the dataset:

{
  "email": "john.doe@example.com",
  "response": 200,
  "message": "deliverable",
  "status": "✅",
  "success": true,
  "responseData": {
    "status": "deliverable",
    "deliverable": true
  },
  "timestamp": "2024-01-15T10:30:00.000Z"
}

Output Fields

Field	Type	Description
email	String	The validated email address
response	Number	HTTP response code from validation API
message	String	Validation result: deliverable, risky, or undeliverable
status	String	Visual status indicator: ✅ (deliverable), ⚠️ (risky), or ❌ (undeliverable)
success	Boolean	Whether the validation request succeeded
responseData	Object	Full response data from validation API (on success)
error	String	Error details (only present when success is false)
timestamp	String	ISO timestamp of when validation was performed

🔧 Usage Example

Using Apify Client

You can integrate this Actor into your product with just a few lines of code:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

// Run the Actor
const run = await client.actor('YOUR_USERNAME/clean-email-validator').call({
  emails: [
    "john.doe@example.com",
    "jane.smith@company.com",
    "info@business.org"
  ]
});

// Fetch results
const { items } = await client.dataset(run.defaultDatasetId).listItems();

// Process results
items.forEach(item => {
  console.log(`${item.email}: ${item.status} ${item.message}`);
});

Using Apify API

curl -X POST https://api.apify.com/v2/acts/YOUR_USERNAME~clean-email-validator/runs \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "emails": [
      "john.doe@example.com",
      "jane.smith@company.com"
    ]
  }'

📊 Validation Status Types

✅ Deliverable

Email is valid, active, and can receive messages. Safe to use for sending.

⚠️ Risky

Email may have issues such as:

• Catch-all domain
• Temporary/disposable email service
• Role-based address (info@, admin@, etc.)
• Low sender reputation

❌ Undeliverable

Email cannot receive messages due to:

• Invalid syntax
• Non-existent domain
• Mailbox doesn't exist
• Domain not accepting mail

🎯 Use Cases

• Lead Validation: Clean your lead lists before outreach campaigns
• Form Validation: Verify emails during user registration in real-time
• Database Cleaning: Remove invalid emails from your existing database
• Email Marketing: Ensure high deliverability rates and protect sender reputation
• CRM Integration: Validate contacts before adding to your CRM system
• List Hygiene: Regular maintenance of email lists for better engagement
• Compliance: Maintain clean contact lists for GDPR and CAN-SPAM compliance

⚡ Technical Details

Processing Flow

1. Actor receives array of email addresses from input
2. Each email is validated sequentially with a separate API call
3. Results are saved individually as they're processed
4. Final summary shows total processed, successful, and failed validations

API Integration

• Endpoint: Secure webhook-based validation service
• Method: POST
• Content-Type: application/json
• Response Time: Typically 1-3 seconds per email
• Timeout: 30 seconds per request

Performance

• Memory: 128-256 MB
• Processing Speed: ~1-2 emails per second
• Recommended Batch Size: Up to 500 emails per run
• Runtime: Scales linearly with number of emails

🛡️ Error Handling

The Actor handles various error scenarios:

• ✅ Invalid email format detection
• ✅ Network timeout handling
• ✅ API connection errors
• ✅ Missing required fields validation
• ✅ Webhook failures with detailed error messages
• ✅ Individual email failures don't stop batch processing

📈 Results Summary

At the end of each run, you'll receive a summary log:

Processing complete. Total: 100, Successful: 95, Failed: 5

Each failed validation includes detailed error information in the output.

🔍 Output Views

The Actor provides a convenient Overview view in the Apify Console showing:

• Email address
• Status emoji (✅/⚠️/❌)
• Verification result
• Response code
• Success indicator
• Error details (if any)
• Timestamp

💡 Best Practices

1. Batch Processing: Group emails in batches of 100-500 for optimal performance
2. Rate Limiting: Be mindful of API rate limits when processing large lists
3. Result Filtering: Use the status field to filter deliverable emails
4. Error Handling: Check the success field before using validation results
5. Regular Validation: Re-validate email lists periodically for accuracy

🔐 Privacy & Security

• Email addresses are processed securely via encrypted webhook
• No email data is stored permanently by the Actor
• Results are stored in your private Apify dataset
• Compatible with GDPR and data protection regulations

📚 Integration Examples

Filter Only Deliverable Emails

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const deliverableEmails = items
  .filter(item => item.message === 'deliverable')
  .map(item => item.email);
console.log('Deliverable emails:', deliverableEmails);

Export Results to CSV

// Get dataset items in CSV format
const csvUrl = `https://api.apify.com/v2/datasets/${run.defaultDatasetId}/items?format=csv`;
// Download or process CSV as needed

Webhook Integration

Set up a webhook to receive results automatically when the Actor finishes:

const run = await client.actor('YOUR_USERNAME/clean-email-validator').call(
  { emails: [...] },
  { webhooks: [{ eventTypes: ['ACTOR.RUN.SUCCEEDED'], requestUrl: 'YOUR_WEBHOOK_URL' }] }
);

🆘 Support

Need help or have questions?

• 📧 Email: business@karbon-tech.store
• 📝 Create an issue in the Actor repository
• 💬 Contact Apify support for platform-related questions

📄 License

This Actor is provided by Karbon Tech Store LLC.

---

Version: 0.0.1
Author: Karbon Tech Store LLC
Last Updated: November 2025

🌟 Start Validating

Ready to clean your email lists? Run this Actor now or integrate it into your workflow with the Apify API!