Find and verify emails for HubSpot prospects using Apollo and Hunter in Make

Prerequisites

Why Make?

Make's Router module is a natural fit for the verification branching logic. Route Apollo-verified emails directly to HubSpot update, and route unverified emails through Hunter first. The visual scenario layout makes this fork-and-merge pattern easy to build and debug.

The trade-off is credit consumption. Each contact passes through 4-6 modules, and every module execution counts as a credit. For 50 contacts with full verification, that's 200-300 Make credits per run. The Code approach processes the same batch with zero platform credits.

Overview

Make handles this workflow well because it iterates over search results automatically and supports conditional routing for the verification logic. The scenario: search HubSpot for contacts without emails → find emails via Apollo → conditionally verify with Hunter → write back to HubSpot.

Step 1: Create the scenario and schedule

Create a new scenario. Set the schedule:

• Schedule type: At regular intervals
• Run scenario: Every day
• Time: 06:00
• Timezone: Your team's timezone

Step 2: Search HubSpot for contacts without emails

Add an HTTP module (Make an API Call):

• URL: https://api.hubapi.com/crm/v3/objects/contacts/search
• Method: POST
• Headers: Authorization handled by HubSpot connection
• Body (JSON):

{
  "filterGroups": [{
    "filters": [
      {"propertyName": "email", "operator": "NOT_HAS_PROPERTY"},
      {"propertyName": "firstname", "operator": "HAS_PROPERTY"},
      {"propertyName": "company", "operator": "HAS_PROPERTY"}
    ]
  }],
  "properties": ["firstname", "lastname", "company", "domain"],
  "limit": 100
}

Step 3: Iterate over contacts

Add an Iterator module:

• Array: Map {{1.results}} from the search response

This emits one bundle per contact, allowing the downstream modules to process each contact individually.

Step 4: Call Apollo to find the email

Add an HTTP module:

• URL: https://api.apollo.io/api/v1/people/match
• Method: POST
• Headers: x-api-key: YOUR_APOLLO_KEY, Content-Type: application/json
• Body:

{
  "first_name": "{{2.properties.firstname}}",
  "last_name": "{{2.properties.lastname}}",
  "organization_name": "{{2.properties.company}}"
}

Add a Filter on the connection after the Apollo module:

• Condition: person.email exists

Step 5: Route based on email confidence

Add a Router module with two routes:

Route 1 — Apollo already verified (skip Hunter):

• Filter condition: person.email_status equals verified
• This route goes directly to the HubSpot update step

Route 2 — Needs Hunter verification:

• Filter condition: person.email_status does not equal verified

On Route 2, add an HTTP module for Hunter:

• URL: https://api.hunter.io/v2/email-verifier
• Method: GET
• Query string:
  • email: {{3.person.email}}
  • api_key: Your Hunter API key

Add a Filter after Hunter:

• Condition: data.result equals deliverable

Step 6: Update HubSpot with the verified email

Both routes converge on an HTTP module:

• Method: PATCH
• URL: https://api.hubapi.com/crm/v3/objects/contacts/{{2.id}}
• Headers: Authorization via HubSpot connection
• Body:

{
  "properties": {
    "email": "{{3.person.email}}",
    "email_verification_status": "verified",
    "email_source": "{{ifempty(5.data.result; 'apollo-verified'); 'apollo+hunter'}}"
  }
}

For contacts where Hunter returned risky or undeliverable, add a separate route that updates only the flag without writing the email.

Step 7: Add error handling and activate

1. Add Resume error handlers on the Apollo and Hunter HTTP modules (handles 429 rate limit responses)
2. Add a Sleep module (1 second) after the Apollo call to respect rate limits within the Iterator loop
3. Click Run once to test with a few contacts
4. Verify HubSpot contacts have updated emails
5. Toggle the scenario to Active

Cost and credits

• Make Free plan: 1,000 credits/month. Each contact uses ~4-6 credits. Handles ~166-250 contacts/month.
• Make Core plan: $29/mo for 10,000 credits. Handles ~1,600-2,500 contacts/month.
• Apollo: 1 credit per lookup ($49/mo Basic = 900 credits)
• Hunter: 1 credit per verification ($49/mo Starter = 1,000 verifications). Apollo-verified emails skip Hunter entirely.
• Typical split: If 40% of Apollo results are pre-verified, you save 40% on Hunter credits.

Common questions

How many Make credits does each contact use?

A full find→verify→update flow uses 4-6 credits per contact depending on the path. Apollo-verified contacts (skip Hunter) use ~4 credits. Contacts requiring Hunter verification use ~6. The Free plan (1,000 credits) handles ~166-250 contacts/month.

Can I use this on Make's Free plan?

Yes, but the Router module and conditional logic are available on all plans. The main constraint is the 15-minute polling interval on Free (vs. 1 minute on Core) and the 1,000 credit/month limit.

What if my contacts have domains but not company names?

Apollo's People Match works better with a domain than a company name. If your contacts have a domain property, pass it as domain in the request body instead of (or in addition to) organization_name.

Next steps

• Add a Slack notification — append a Slack module at the end to summarize: "Found 12 emails, verified 10, 2 risky"
• Handle no-match contacts — route contacts where Apollo returned no email to a separate HubSpot list for manual research
• Add a domain lookup step — if contacts lack a domain, add a Hunter Domain Search step before Apollo to find the company domain first