How to Verify Emails in n8n, Make and Zapier (No-Code Workflows)

A lot of email lists never touch a line of code. Leads come in from a form, land in a Google Sheet, get enriched, and get pushed into a CRM or a sending tool, all wired together in n8n, Make or Zapier. That's exactly where bad addresses slip through: nobody is looking at the rows, and the first sign of a problem is a bounce report.

This post shows how to put a verification step into those workflows. I'll start with n8n, because I built and published a community node for it, then cover Make and Zapier, which don't have a MailRambo app but can call the API with their generic HTTP modules. At the end there's a complete lead-cleaning workflow you can copy.

What the verification step returns

Whatever tool you use, the answer is the same small JSON object:

{
  "email": "jane@acme.com",
  "deliverable": true,
  "reason": "mailbox_exists",
  "credits_remaining": 842
}

deliverable is true only when the mailbox is confirmed. Catch-all domains and servers that won't give a clear answer come back as false, with a reason that says why. I designed it that way on purpose: a no-code workflow is a bad place to interpret "risky" or "unknown". You want one field to branch on.

There are two modes:

Fast mode can prove an address is bad but can't prove it's good. In a workflow, that makes it a free pre-filter: drop the obvious junk with fast mode, then spend credits on full checks only for what's left.

Two more details that matter for automations: repeat checks of the same address from the same account within 24 hours are free (the response includes "cached": true), and invalid syntax is never charged. So if a workflow re-runs on the same rows while you're testing it, you don't pay twice.

n8n: the MailRambo community node

Install it

In n8n, go to Settings > Community Nodes > Install and enter n8n-nodes-mailrambo. On self-hosted n8n you can also run npm install n8n-nodes-mailrambo in your ~/.n8n/custom folder and restart.

A small build-in-public note: publishing a verified n8n node in 2026 means publishing from GitHub Actions with npm provenance, and npm then holds new versions for an automated review before they go live. If you're on a brand-new release day, the latest version may take a little while to appear.

Add a credential with a test key first

Create an API key on the API Keys page and add it as a MailRambo API credential. I strongly recommend starting with a test key (mr_test_...). Test keys never contact mail servers and never use credits; the answer depends on the part before the @:

• deliverable@example.com returns true / mailbox_exists
• disposable@example.com returns false / disposable
• catch_all@example.com returns false / catch_all
• not_found@example.com (or anything else) returns false / mailbox_not_found

That lets you build and debug every branch of the workflow for free. Swap in a live key (mr_live_...) when you're done.

Verify Email: Full or Fast

Add a MailRambo node and pick Verify Email. Set Email to an expression like {{ $json.email }} and choose a mode:

• Mode: Full (default, 1 credit) confirms the mailbox. Turn on Full Detail to also get the A-F lead grade, inbox provider, flags and SPF/DKIM/DMARC/BIMI/PTR results for the same credit.
• Mode: Fast is free and sub-second.

The node outputs deliverable and reason as regular fields, so the next node can use them directly.

Branch with an IF node

Add an IF node with the condition {{ $json.deliverable }} is true. The true branch goes to your CRM or sending tool. The false branch goes somewhere you can review it, such as a "removed" sheet with the reason column. I'd keep that sheet: it's the fastest way to spot a lead source that's sending you junk.

Lists: Start Batch and Get Batch

For a few hundred rows, one Verify Email call per item is fine. For bigger lists, use Start Batch with up to 200 addresses (separated by commas, spaces or new lines, or an array expression). It returns a batch_id. Then loop:

1. Wait about 30 seconds.
2. Get Batch with the batch_id.
3. IF status is completed, continue with results; otherwise go back to Wait.

There's also Get Account, which is free and returns your remaining credits. It's handy as a first step in a scheduled workflow so you can stop early, or alert yourself, before a big run.

Make and Zapier: call the API over HTTP

Make and Zapier don't have a MailRambo app, but both have a generic HTTP step (Make's HTTP module and Zapier's Webhooks by Zapier or code steps). I won't guess at the exact field labels, since they change, but the request you need to build is always the same:

As a raw request it looks like this:

curl -X POST "https://www.mailrambo.com/v1/verify" \
  -H "Authorization: Bearer mr_test_..." \
  -H "Content-Type: application/json" \
  -d '{"email": "deliverable@example.com"}'

Once the response is parsed, map deliverable and reason into later steps. In Make, put a filter on the route after the HTTP module (deliverable equals true). In Zapier, use a Filter or Paths step on the same field.

A few things to handle in either tool:

• Store the key as a secret or connection, not pasted into a visible text field that gets shared with the scenario.
• Errors come back as {"error": "...", "message": "..."} with a non-2xx status. 402 insufficient_credits means you're out of credits; 429 rate_limited means back off and retry; 503 provider_unavailable is refunded automatically and safe to retry. Decide what the workflow should do on each: I'd route errors to a "check later" list rather than dropping or passing the lead silently.
• Rate limits: 600 requests a minute per key, with sustained full checks fair-use at about 5 per second per account. If you're iterating over a big sheet, add a short delay or use the batch endpoint (POST /v1/verify/batch, up to 200 addresses, then poll GET /v1/verify/batch/{batch_id}).

Batches in Make or Zapier work the same way as in n8n, but the polling loop is more awkward to build. If you're cleaning large lists regularly, n8n is the easier fit.

Example: a lead-cleaning workflow

Here's the workflow I'd build for a team that collects leads in a sheet and sends from a cold email tool. The steps map to n8n node names, but the same shape works in Make or Zapier.

1. Trigger: a new row in Google Sheets (or a schedule that reads unprocessed rows).
2. Normalize: trim whitespace and lowercase the email. Skip empty values.
3. Fast check (free): Verify Email, Mode Fast.
4. IF deliverable is false: write the row with reason to the "removed" sheet. possible_typo rows come with a suggestion field, which is worth a human look rather than an automatic fix.
5. Full check (1 credit): Verify Email, Mode Full, for rows that passed.
6. IF deliverable is true: push to the CRM or sending tool. If reason is role_account (like info@ or sales@), you may want a separate segment for cold outreach.
7. Else: write to "removed" with the reason.
8. Mark the source row as processed so it doesn't run again.

The fast step costs nothing and catches disposable domains, typos and domains with no mail server, so the credits go only to addresses that have a real chance. For more on what to do with each result in outreach, see how to clean an email list before a cold email campaign.

How the reasons map to workflow actions

Try it

You can build the whole workflow with a free test key before spending anything. Every account gets 100 free checks a month, fast mode is always free, and the full API reference is on the developers page.