How to verify emails in Make.com with the HTTP module and a Router
· Updated · 6 min read · Tutorials
To verify emails in Make.com, add the HTTP app's Make a request module after your trigger, send a POST with the address to https://pingutil.com/v1/verify, turn on Parse response, and then add a Router with one route per status: valid, risky, unknown and invalid. Each route gets a filter on the parsed status, and a fallback route catches anything you didn't plan for. The whole scenario is four or five modules.
This tutorial sticks to Make features documented in its HTTP app reference and Router help page. Labels in Make's UI change from time to time, so if a field name differs slightly in your account, look for the closest match.
What the scenario looks like
- Trigger: wherever leads arrive (a form tool, a webhook, a new spreadsheet row, a new CRM contact).
- HTTP > Make a request: POST the email to
/v1/verify. - Router with four routes:
valid: create or update the contact and continue your normal flow.risky: create the contact with a tag such asemail_risky.unknown: store it with a tag such asemail_recheck.- fallback: anything else, including
invalid, goes to a log or a review sheet.
- Action modules at the end of each route.
If you've built the same thing in Zapier, the structure is identical. Our Zapier webhook tutorial uses Paths where Make uses a Router.
Step 1: pick a trigger that exposes the email as a field
Any trigger works if its output includes the email address as a mappable item. Run the trigger once ("Run once" on the scenario) so Make has a sample bundle. Without a sample, you'll be mapping blind in the next step.
If the email comes in with stray whitespace or capital letters, that's fine. The API trims and lowercases the address (and converts international domains to punycode), and returns the normalized form in email.
Step 2: configure Make a request
Add a module, choose the HTTP app, then Make a request. Fill it in like this:
| Field | Value |
|---|---|
| URL | https://pingutil.com/v1/verify |
| Method | POST |
| Headers | Name Authorization, value Bearer pk_live_... (your pingutil API key) |
| Body content type | JSON (application/json) |
| Body input method | Data structure, with one key email mapped to the trigger's email field |
| Parse response | Yes |
| Timeout (advanced settings) | 30 |
| Return error if HTTP request fails | Yes |
Two notes on these settings:
- Use Data structure rather than JSON string for the body. Make's docs say the data-structure method escapes reserved JSON characters for you; with a raw JSON string you have to escape them yourself. An address with a quote or backslash in it would otherwise break the request.
- Keep the key out of the URL. It goes in the
Authorizationheader only. Make's HTTP app also lists an API key authentication type; a plain header works and is easier to read when you come back to the scenario.
If you prefer the raw JSON string method, the body is:
{ "email": "{{1.email}}" }
where {{1.email}} is whatever Make inserts when you map the trigger's email field.
Run the module once. With Parse response on, the output bundle contains the parsed JSON body (shown as Data in the module output), so its fields become mappable. A typical response, trimmed:
{
"email": "jane@acme.com",
"input": "jane@acme.com",
"status": "risky",
"reason": "accept_all",
"score": 55,
"did_you_mean": null,
"checks": {
"syntax": true,
"disposable": false,
"free_provider": false,
"role_based": false,
"randomized": false,
"domain_exists": true,
"has_mx": true,
"mailbox": "accept_all",
"catch_all": true
},
"mx_host": "mx1.acme.com",
"cached": false,
"checked_at": "2026-11-16T09:12:00.000Z"
}
The values above are illustrative. The fields are real: status, reason, score (0 to 100), did_you_mean for likely typos of big providers, and checks with the individual facts. Their meanings are in the status reference.
Why 30 seconds
The verifier has to talk to the recipient's mail server. Most checks take one to five seconds; a slow mail server can take up to about 25. If Make gives up first, you get an error instead of an answer. Make's HTTP module accepts a timeout from 1 to 300 seconds, so 30 leaves headroom without letting a stuck run hang for minutes.
Step 3: add the Router and filters
Add a Router after the HTTP module. Make processes routes one after another, in order, so put the most common outcome first if you care about run time.
On each route, click the line between the Router and the next module to open the filter, give it a label, and add one condition:
| Route label | Condition |
|---|---|
| Valid | Data: status (text) equal to valid |
| Risky | Data: status equal to risky |
| Unknown | Data: status equal to unknown |
| Fallback | Set as the fallback route |
Make's Router page describes the fallback route as the one that "processes data that doesn't fit the condition of all other routes". Use it for invalid, and for anything unexpected if the API ever adds a value you didn't map. That's safer than a fourth explicit route, because a bundle that matches no route is simply not processed any further, and you'd never see it.
Optional: split invalid by reason
invalid covers several things: invalid_syntax, disposable_domain, no_domain, no_mx, null_mx, mailbox_not_found and mailbox_disabled. If your fallback route ends in a review sheet, write Data: reason into a column so whoever reviews it knows why. If you get a lot of disposable_domain from a particular form, that's a sign the form is being abused rather than mistyped.
Step 4: what each route should do
| Route | Suggested action | Why |
|---|---|---|
| Valid | Create the contact, start the sequence or welcome flow | The server confirmed the mailbox |
| Risky | Create the contact, add a tag, maybe hold back from cold sends | Catch-all domains, role addresses (info@), full mailboxes, randomized local parts |
| Unknown | Create the contact with a re-check tag; verify again later | Greylisting, blocks and timeouts are temporary |
| Invalid (fallback) | Don't add to the CRM or mailing list; log it | Sending will bounce |
Risky addresses at catch-all domains are often real people at real companies. A catch-all server accepts any address during the check, so no verifier can confirm the mailbox. Blocking them throws away good leads; catch-all email domains explains the trade-off.
For unknown, a simple pattern is a second scenario on a schedule that reads rows tagged email_recheck and runs the same HTTP call again. We cache greylisted, blocked and rate-limited answers for one hour, so space re-checks at least an hour apart.
Handling errors and rate limits
With Return error if HTTP request fails set to Yes, a 4xx or 5xx response stops the bundle with an error instead of passing an error body down the Router as if it were a result. That's what you want. The two errors you'll see in practice:
- 401
unauthorized: the key is wrong or missing. Fix the header. - 429 with
error: "rate_limited": more than 60 requests a minute on your account. The body includesretry_after_seconds. If your trigger fires in large bursts (an import of hundreds of rows), slow it down or process the import in smaller runs. - 429 with
error: "quota_exceeded": the account's daily verification budget is used up. Retries won't help until the next UTC day.
Make lets you attach an error handler route to a module. Whatever you choose there, don't route errors into the Valid branch. A failed check is not a passed check.
Before you turn it on
- Map the email field, not the whole bundle, into the body.
- Turn on Parse response and run the HTTP module once so
Data: statusis mappable. - Set the timeout to 30 seconds.
- Add a fallback route.
- Decide what risky and unknown mean for your team, and write it into the route labels.
- Test with a few addresses in the verification demo first so you know what each status looks like.
For the reasoning behind each status decision when leads go straight into a CRM, read the guide on verifying leads before they reach your CRM. Field details are in the API reference, and the Make integration page has the setup steps in short form.
Questions people ask
- Can Make.com verify email addresses on its own?
- Make has no built-in mailbox check. You call a verification API from the HTTP app's Make a request module and then branch on the status it returns, using a Router and filters.
- What timeout should I set on the HTTP module for email verification?
- Around 30 seconds. Most checks finish in one to five seconds, but a slow or greylisting mail server can take up to about 25. Make's HTTP module accepts a timeout between 1 and 300 seconds under its advanced settings.
- Should the scenario drop leads that come back unknown?
- No. Unknown means the recipient's mail server didn't give a definite answer, often because of greylisting or a temporary block. Keep the lead, tag it, and re-check it later.