HubSpot

Email checker for HubSpot. Verify contacts and clean email lists in HubSpot CRM.

Keep your HubSpot CRM clean and improve lead quality by automatically verifying email addresses when contacts are created or updated.

Overview

Integrating EmailVerify with HubSpot helps you:

Qualify leads instantly - Verify emails as contacts enter your CRM
Maintain data quality - Keep your contact database clean
Improve deliverability - Ensure marketing emails reach real people
Reduce bounce rates - Filter out invalid addresses before campaigns

Integration Methods

Method	Best For	Complexity
Workflows	Automated verification	Low
Custom Code	Advanced logic	Medium
Zapier/Make	No-code automation	Low
Direct API	Full control	High

Method 1: HubSpot Workflows (Recommended)

Use HubSpot workflows with webhooks to verify emails automatically.

Step 1: Create a Custom Property

First, create properties to store verification results:

Go to Settings → Properties
Click Create property
Create these properties:

Property Name	Type	Field Type
Email Verification Status	Single-line text	Text
Email Verification Score	Number	Number
Email Verified Date	Date	Date picker
Is Disposable Email	Single checkbox	Checkbox

Step 2: Create the Workflow

Go to Automation → Workflows
Click Create workflow → From scratch
Select Contact-based workflow
Set enrollment trigger:

Trigger: Contact is created
OR
Trigger: Email is updated

Step 3: Add Webhook Action

Add action: Trigger a webhook
Configure the webhook:

Method: POST

URL:

https://api.emailverify.ai/v1/verify

Request Headers:

Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

Request Body:

{
  "email": "{{contact.email}}"
}

Step 4: Handle the Response

Add a Custom code action to process the response:

const response = JSON.parse(event.webhook.response);

// Map verification results to contact properties
const outputFields = {
  email_verification_status: response.status,
  email_verification_score: response.score,
  email_verified_date: new Date().toISOString(),
  is_disposable_email: response.result.disposable
};

// Return properties to update
callback(outputFields);

Step 5: Branch by Results

Add branching logic based on verification status:

If email_verification_status equals "valid"
  → Continue with lead nurturing
  → Add to marketing list

If email_verification_status equals "invalid"
  → Remove from marketing lists
  → Update lifecycle stage to "Other"

If email_verification_status equals "unknown"
  → Add to "Needs Review" list

Method 2: Custom Integration with Operations Hub

For advanced use cases, use HubSpot Operations Hub with custom code:

Create a Custom Code Action

const axios = require('axios');

exports.main = async (event, callback) => {
  const email = event.inputFields['email'];

  try {
    const response = await axios.post(
      'https://api.emailverify.ai/v1/verify',
      { email },
      {
        headers: {
          'Authorization': `Bearer ${process.env.EMAILVERIFY_API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );

    const result = response.data;

    callback({
      outputFields: {
        verification_status: result.status,
        verification_score: result.score,
        is_deliverable: result.result.deliverable,
        is_disposable: result.result.disposable,
        is_role_based: result.result.role,
        is_free_email: result.result.free
      }
    });
  } catch (error) {
    callback({
      outputFields: {
        verification_status: 'error',
        error_message: error.message
      }
    });
  }
};

Set Up Environment Secrets

Go to Settings → Integrations → Private Apps
Create a private app or use existing
Add secret: EMAILVERIFY_API_KEY

Method 3: Zapier Integration

For no-code implementation, use Zapier:

Zap Configuration

Trigger: HubSpot → New Contact
    ↓
Action: Webhooks → POST to EmailVerify
    ↓
Action: HubSpot → Update Contact

Configuration:
  - Email: {{Contact Email}}
  - Properties to update:
    - email_verification_status: {{status}}
    - email_verification_score: {{score}}

See our Zapier Integration Guide for detailed instructions.

Use Cases

1. Lead Scoring Enhancement

Add email quality to your lead scoring model:

Lead Score Adjustments:
  - Valid business email: +15 points
  - Valid free email: +5 points
  - Disposable email: -20 points
  - Role-based email: -5 points
  - Invalid email: -50 points

Workflow Implementation:

If email_verification_status = "valid"
  AND is_disposable_email = false
  AND is_free_email = false
    → Add 15 to HubSpot Score

If is_disposable_email = true
    → Add -20 to HubSpot Score

2. Marketing List Hygiene

Clean lists before campaigns:

Create Active List:
  - email_verification_status = "valid"
  - is_disposable_email = false
  - Marketing contact = true

Exclude from campaigns:
  - email_verification_status = "invalid"
  - OR is_disposable_email = true

3. Sales Team Notifications

Alert sales when high-quality leads arrive:

If email_verification_status = "valid"
  AND email_verification_score > 0.9
  AND is_free_email = false
    → Send internal notification
    → Create task for sales rep

4. Form Submission Verification

Verify emails from form submissions:

Workflow Trigger: Form submission on any form

Actions:
  1. Verify email with EmailVerify
  2. If valid → Continue normal flow
  3. If invalid → Send "please use valid email" notification

Massen-Verifizierung

For existing contacts, create a bulk verification workflow:

Option 1: Scheduled Workflow

Trigger: Scheduled (weekly)
Enrollment: Contacts where
  - email_verified_date is unknown
  - OR email_verified_date is more than 90 days ago
  - Limit: 1000 contacts per run

Option 2: Export and Import

Export contacts to CSV
Use EmailVerify bulk API or dashboard
Import results back to HubSpot

// Bulk verification script
const contacts = await hubspot.crm.contacts.getAll();
const emails = contacts.map(c => c.properties.email);

// Submit to EmailVerify bulk API
const job = await emailVerify.verifyBulk(emails);

// Wait for completion
const results = await emailVerify.getBulkResults(job.job_id);

// Update HubSpot contacts
for (const result of results) {
  await hubspot.crm.contacts.update(
    result.email,
    {
      properties: {
        email_verification_status: result.status,
        email_verification_score: result.score
      }
    }
  );
}

Custom Contact Properties Reference

Create these properties for full integration:

Property	Internal Name	Type	Options
Email Verification Status	`email_verification_status`	Dropdown	valid, invalid, unknown, accept_all
Verification Score	`email_verification_score`	Number	0-1
Verified Date	`email_verified_date`	Date	-
Is Disposable	`is_disposable_email`	Checkbox	-
Is Role-Based	`is_role_based_email`	Checkbox	-
Is Free Provider	`is_free_email_provider`	Checkbox	-
Is Catch-All Domain	`is_catchall_domain`	Checkbox	-

Reporting and Dashboards

Create Verification Reports

Build reports to track email quality:

Contact Quality Report:

Total contacts by verification status
Verification score distribution
Disposable email percentage

Lead Source Quality:

Verification status by lead source
Compare quality across channels

Trend Analysis:

Invalid emails over time
Improvement after cleaning

Dashboard Widgets

Widget 1: Email Quality Pie Chart
  - Segments: valid, invalid, unknown
  - Filter: Created in last 30 days

Widget 2: Verification Score Histogram
  - X-axis: Score ranges (0-0.5, 0.5-0.8, 0.8-1.0)
  - Y-axis: Contact count

Widget 3: Disposable Email Trend
  - Line chart over time
  - Goal: Reduce to less than 5%

Best Practices

1. Verify at Entry Points

Verify emails immediately when contacts are created:

Form submissions
Import processes
API integrations
Manual entry

2. Re-verify Periodically

Email validity changes over time:

Set up monthly re-verification for active contacts
Re-verify before major campaigns
Track verification date to identify stale data

3. Handle Unknown Results

For unknown status emails:

Don't immediately remove them
Flag for review
Try re-verification after 24 hours
Use sender reputation data as backup signal

4. Segment by Quality

Create smart lists based on email quality:

High Quality:
  status = "valid" AND score > 0.8 AND disposable = false

Medium Quality:
  status = "valid" AND (score <= 0.8 OR disposable = true)

Low Quality:
  status = "invalid" OR status = "unknown"

5. Protect Sender Reputation

Never send to invalid emails:

Exclude invalid status from all marketing lists
Monitor bounce rates after campaigns
Investigate sources of bad data

Fehlerbehebung

Workflow Not Running

Check enrollment criteria
Verify workflow is turned on
Check for conflicting workflows
Review workflow error logs

Webhook Errors

Verify API key is correct
Check webhook URL is accessible
Review request/response in workflow history
Test API call in Postman first

Properties Not Updating

Check property internal names match exactly
Verify custom code returns correct field names
Check user permissions for property updates

HubSpot

ActiveCampaign Integration

Zapier Integration

API Reference

On this page