Package Information
Available Nodes
Documentation generating…
Documentation
n8n-nodes-reoon-email-verifier-aim
An n8n community node for the official Reoon Email Verifier API.
Verify a single address in Quick or Power mode, submit bulk tasks of up to 50,000 addresses, poll their progress, and check your account balance — all without writing a single HTTP request or pasting your API key into a workflow.
n8n is a fair-code licensed workflow automation platform.
Install
In your self-hosted n8n:
Settings → Community Nodes → Install
Enter the package name:
n8n-nodes-reoon-email-verifier-aim
Confirm that you understand the risks of installing community nodes, and install. The node appears as Reoon Email Verifier in the node panel.
See the n8n community nodes installation docs for the full procedure.
Credential
The node ships one credential: Reoon Email Verifier API.
- Get your API key from your Reoon account, under API settings.
- In n8n, create a new Reoon Email Verifier API credential.
- Paste the key into the API Key field and save.
That is the only place the key is ever entered. Every operation reads it from the credential and puts it where the API expects it — in the query string, or in the JSON body for bulk task creation. You never write the key into a node parameter, an expression, or an HTTP Request node.
Use Test on the credential to confirm it works: it calls the account balance endpoint, which does not consume verification credits.
The key is never written to the node output, never included in error messages, and never appears in logs.
Operations
Email → Verify Single Email
Verifies one address per input item.
| Parameter | Description |
|---|---|
| The address to verify | |
| Verification Mode | Power (default) or Quick |
| Request Timeout | Milliseconds. Default 120000. |
Quick mode is fast. It checks syntax, domain, MX records, disposable addresses and role accounts. It does not confirm that the individual mailbox exists — a valid result means the domain will accept mail, not that this specific inbox is real.
Statuses: valid, invalid, disposable, spamtrap.
Power mode performs deep verification, adding SMTP connectivity, deliverability, catch-all detection, disabled mailboxes and full inboxes. It can take from a few seconds to over a minute per address, which is why the timeout defaults to two minutes.
Statuses: safe, invalid, disabled, disposable, inbox_full, catch_all, role_account, spamtrap, unknown.
The full API response is returned unchanged, including overall_score, is_safe_to_send, mx_records and every other field Reoon provides.
Reoon advises against using the single-verification endpoint as a bulk mechanism, and against calling it with more than five concurrent threads. For lists, use Bulk Task.
Bulk Task → Create Bulk Task
Submits up to 50,000 unique addresses as one asynchronous task. Bulk verification always runs at Power-mode depth — there is no mode selector.
| Parameter | Description |
|---|---|
| Task Name | Optional. Maximum 25 characters, validated before the request. |
| Email Source | Input Items (default) or Manual List |
| Email Field | Only for Input Items. Default email. Dot notation supported. |
| Emails | Only for Manual List. One address per line. |
Email Source: Input Items
The node collects the address from every item it receives. No code, no Code node, no expression.
If the previous node outputs:
{ "email": "a@empresa.com" }
{ "email": "b@empresa.com" }
{ "email": "c@empresa.com" }
set:
- Email Source =
Input Items - Email Field =
email
and the node builds the payload for you:
["a@empresa.com", "b@empresa.com", "c@empresa.com"]
Nested fields work too — set Email Field to contact.email for { "contact": { "email": "a@empresa.com" } }.
Email Source: Manual List
Paste addresses directly, one per line (commas and semicolons also work):
email1@empresa.com
email2@empresa.com
email3@empresa.com
Normalization
Whichever source you use, the node applies the same conservative cleanup before sending:
- trims surrounding whitespace,
- lowercases,
- drops empty lines,
- removes duplicates, keeping the first occurrence.
Nothing else is rewritten. Dots and +tag suffixes are preserved, because changing them would change which address gets verified.
The whole node run produces one task, regardless of how many input items arrive.
Response
On success the API returns HTTP 201 with status, task_id, count_submitted, count_duplicates_removed, count_rejected_emails and count_processing. The node returns all of it, plus three local counters so you can see what the deduplication did:
| Field | Meaning |
|---|---|
count_input |
Addresses found after trimming and dropping empties |
count_unique |
Addresses left after deduplication |
count_sent |
Addresses actually submitted to Reoon |
Keep task_id — you need it to fetch the results.
Bulk Task → Get Bulk Result
Fetches the progress or the finished results of a task.
| Parameter | Description |
|---|---|
| Task ID | The task_id from Create Bulk Task |
| Output Mode | Full Task Response (default) or One Item per Email |
Task statuses: waiting, running, completed, file_not_found, file_loading_error.
While the task is waiting or running, the node simply returns the current state. It does not poll internally — the waiting loop belongs in the workflow, where you can see it and control it.
Output Mode: Full Task Response returns the whole API response as one item. Use this while polling, so status stays reachable for an IF node.
Output Mode: One Item per Email splits the results into one n8n item per verified address once the task is completed. Before completion it falls back to the full response, so the same node works in both phases. Each item carries every field Reoon returned, a guaranteed email field, and a _reoon_task object with the task metadata.
Account → Check Account Balance
Returns the account status and remaining credits:
{
"api_status": "active",
"remaining_daily_credits": 150,
"remaining_instant_credits": 5000,
"status": "success"
}
This endpoint does not consume verification credits, which makes it the right first call to confirm the installation works.
Bulk polling pattern
Because the node deliberately does not poll, build the loop in the workflow:
Create Bulk Task
│
▼
Wait ◄──────────────┐
│ │
▼ │
Get Bulk Result │
│ │
▼ │
IF status = completed │
├── false ─────────┘
│
└── true → process the results
- Create Bulk Task → keep
task_id. - Wait → a minute or so is a reasonable starting interval; large lists take longer.
- Get Bulk Result with Output Mode =
Full Task Response. - IF on
{{ $json.status === 'completed' }}.- false → back to Wait.
- true → continue.
- To fan the results out into individual items, add a second Get Bulk Result with Output Mode =
One Item per Email.
This keeps the wait visible and interruptible, and avoids a node that blocks an executor for however long the task takes.
Compatibility
- Tested against n8n 1.121.3 self-hosted.
- Requires Node.js 20.19 or newer, matching n8n's own requirement.
- No runtime dependencies. The node uses only n8n's built-in HTTP helpers.
Notes and API quirks
The Reoon documentation has a few inconsistencies. How this node handles them:
The API key goes in the body for bulk creation. POST /create-bulk-verification-task/ expects key inside the JSON body, not in the query string. Sending it in the query returns HTTP 400 — API key not provided. This node puts it in the body, and a dedicated regression test asserts that the body contains name, emails and key, and that the key does not leak into the query string.
task_id, not task-id. The formal endpoint definition for GET /get-result-bulk-verification-task/ uses task_id with an underscore, while a Python example on the same documentation page shows task-id with a hyphen. This node follows the formal definition and sends task_id.
results can be an array or an object. The prose describes results as an array of objects; the worked example shows an object keyed by email address:
{ "results": { "email1@example.com": { "status": "safe" } } }
The node accepts both shapes. When the object form is used, the key becomes the email field so no address is lost.
No business rules. The node returns Reoon's technical data and nothing else. It does not classify addresses as approved, blocked, or needing review — that belongs in your workflow, where the thresholds are yours to set.
License
This is an independent community node. It is not affiliated with or endorsed by Reoon or n8n.