n8n email verification
Add email verification to n8n workflows
Verifly gives n8n builders a simple REST endpoint for checking email addresses before contacts move into CRMs, sheets, enrichment pipelines, or outbound systems.
GET https://verifly.email/api/v1/verify?email={{$json.email}}
Authorization: Bearer vf_your_api_keyReal-time SMTP mailbox checks
Single, batch, and async bulk verification
Disposable, role account, and catch-all detection
Pay-as-you-go credits with no subscription lock-in
Search fit
Built for n8n email verification workflows
Use Verifly when you need a simple API, predictable pricing, and clean JSON results before emails hit your product, CRM, or campaign tool.
One HTTP Request node, verified at the source
n8n is self-hosted automation, which means the interesting email checks usually happen right where data enters the system — a webhook catching a form submission, a trigger firing on a new CRM row, a scheduled node pulling an enrichment batch. Verifly fits that shape exactly: it's a single REST call, so you drop an HTTP Request node into the flow at the point an email first appears and gate everything after it on the result.
Because n8n gives you real branching with the IF and Switch nodes, you don't have to treat verification as pass/fail. Route deliverable addresses down the happy path, send risky and catch-all ones to a review branch or a Slack ping, and quietly discard disposable ones — all from the same JSON response.
And since n8n runs on your own infrastructure, keeping the Verifly key in n8n's credential store means the API token never leaves your box. The whole check adds one node and a few milliseconds to a workflow that was already running.
How to build the verification step in n8n
- Add an HTTP Request node right after the node that produces an email (Webhook, CRM trigger, Google Sheets, etc.).
- Set Method to GET and URL to https://verifly.email/api/v1/verify. Add a query parameter email set to the expression {{$json.email}}.
- Add a header Authorization with value Bearer vf_your_api_key — or better, store the key as an n8n Header Auth credential and attach it to the node.
- Add an IF node after it. Condition: {{$json.result}} equals deliverable.
- Wire the true output to your real action (create contact, add to sequence) and the false output to a review branch, a log, or a discard.
Method: GET
URL: https://verifly.email/api/v1/verify
Query: email = {{$json.email}}
Header: Authorization = Bearer vf_your_api_key
// Response bound to $json downstream:
// {
// "result": "deliverable", // deliverable | undeliverable | risky
// "disposable": false,
// "role": false,
// "catch_all": false
// }
// IF node: {{$json.result}} == deliverableFAQ
Frequently asked questions
Which n8n node do I use to call Verifly?
The built-in HTTP Request node. Verifly is a plain REST API, so no community node or plugin is required — a GET to /verify with a Bearer header is all it takes.
How do I branch the workflow on the result?
Add an IF node checking {{$json.result}} against 'deliverable', or a Switch node to fan out deliverable / risky / undeliverable into three separate paths. All the flags (disposable, role, catch_all) are available on $json too.
Where should I store the API key in n8n?
Create a Header Auth credential holding Authorization: Bearer vf_your_api_key and attach it to the HTTP Request node. Since n8n is self-hosted, the token stays inside your own instance.
Can I verify a whole batch inside one workflow run?
Yes. Either loop items through the single-email endpoint, or collect the emails and POST them to /verify/batch in one HTTP Request node for a list. The async bulk path scales to 1,000,000 addresses.
Does this work for real-time signup validation?
Yes. Put the HTTP Request node right after a Webhook trigger so a signup or form email is verified before the workflow creates any downstream record, then reject or flag it inline.
Is there an AI-agent-friendly option?
Verifly runs an MCP server at verifly.email/mcp, so an AI Agent node in n8n that speaks MCP can call verification as a tool instead of a manual HTTP request.