For $5/Month, Your n8n Workflows Never Have to Stop at “Check Your Email” Again

Stop letting email verification gates block your automation workflows.

There’s a moment every n8n builder dreads.

You’ve wired up a beautiful workflow — form submission, API calls, data parsing — and then it hits a wall. The service sends a verification email. Your automation just… sits there. Waiting for a human to open Gmail, copy a 6-digit code, and paste it somewhere.

Read this article for free here.

That’s not automation. That’s assisted manual work.

This guide shows you how to solve that problem using UnCorreoTemporal (UCT), a temporary email API built specifically for automation workflows. By the end, you’ll understand what UCT does, why it’s different from other disposable email tools, and how to wire it into a real n8n workflow that handles email verification end-to-end — no human required.

The Core Problem: Email Verification Breaks Automation

Modern services require email verification for almost everything: account creation, trial activations, newsletter signups, API key provisioning, data scraping pipelines, and more.

For humans, this is a minor annoyance. For automated workflows, it’s a hard blocker.

The naive approach — using a shared inbox like Gmail and polling it with IMAP — breaks down quickly. You need credentials stored somewhere, one inbox gets cluttered across multiple workflow runs, emails from different runs mix together, and you have no programmatic way to know which email belongs to which workflow execution.

What you actually need is a dedicated, programmable inbox per workflow run. That’s exactly what UCT provides.

What Is UnCorreoTemporal?

UnCorreoTemporal is a temporary email API with one job: give your automation workflows a real, working email inbox on demand — and let you read the messages it receives via a clean REST API.

Here’s what makes it different from the throwaway inboxes you’d find on sites like Guerrilla Mail:

Programmatic creation. You create inboxes via API. Each n8n execution can spin up its own fresh inbox in milliseconds, with its own unique address.

Two ways to read messages. Poll the messages endpoint on a schedule, or connect via WebSocket for real-time delivery the moment an email arrives — no waiting, no guessing.

Isolation by design. Each inbox is completely separate. Two parallel workflow runs won’t interfere with each other.

API key authentication. Unlike public throwaway mail sites, UCT requires an API key, which means your inboxes are private and not accessible by other users.

Webhooks for event-driven workflows. Register a URL and UCT will notify your n8n webhook trigger the instant an email lands — more on this below.

The practical result: your n8n workflow can create an inbox, use that address to register for a service, get notified the moment the verification email arrives, extract the OTP or confirmation link, and continue — all within a single automated execution.

The Pattern: Create → Register → Wait → Extract → Continue

Before looking at nodes, it helps to understand the conceptual flow. Nearly every email verification scenario follows this exact pattern:

Step 1 — Create Inbox Make a POST request to the UCT API. You get back a unique email address (something like xyz123@uncorreotemporal.com) and a session token.

Step 2 — Use the Address Pass that email address to whatever service you’re automating — a signup form, an API registration call, a web scraping step using a browser node.

Step 3 — Wait for Email Poll the messages endpoint until an email appears, or use UCT’s webhook to have n8n triggered automatically when the email arrives.

Step 4 — Extract What You Need From the email body, pull the OTP code, the magic link, or the confirmation URL using an n8n Code node.

Step 5 — Continue the Workflow Use the extracted value — submit the OTP, click the verification link via HTTP Request, store the confirmed account credentials — and carry on with whatever the workflow was actually trying to accomplish.

This pattern works for virtually any email-gated flow.

Building It in n8n: A Concrete Example

Let’s walk through a specific, practical use case: automatically registering for a service that sends a 6-digit OTP to verify your email address.

You’ll use n8n’s HTTP Request node for all UCT API calls. No custom node needed — UCT’s REST API is simple enough to drive directly.

Node 1: Create a Temporary Inbox

Add an HTTP Request node with the following configuration:

• Method: POST
• URL: [https://uncorreotemporal.com/api/v1/mailboxes?ttl_minutes=30](https://uncorreotemporal.com/api/v1/mailboxes?ttl_minutes=30)
• Authentication: Header Auth → Authorization: Bearer YOUR_API_KEY
• Response Format: JSON

The response will look like this:

{
  "address": "xyz123@uncorreotemporal.com",
  "expires_at": "2026-06-25T11:00:00+00:00"
}

Store address for the next steps. In n8n, you can reference it in subsequent nodes as {{ $('Create Inbox').item.json.address }}.

Node 2: Register with the Service

This node varies depending on what you’re automating. If the service has an API:

• Method: POST
• URL: [https://target-service.com/api/register](https://target-service.com/api/register)
• Body: { "email": "{{ $('Create Inbox').item.json.address }}", "name": "Test User" }

If the service only has a web form, you’d use n8n’s browser automation capabilities or a tool like Puppeteer to fill and submit the form with the UCT address.

Node 3: Wait for the Verification Email

Here you have two options, and which one you use depends on your plan.

Option A — Polling (Builder plan, $5/month)

Add a Wait node followed by an HTTP Request node on a loop:

• Method: GET
• URL: https://uncorreotemporal.com/api/v1/mailboxes/{{ $('Create Inbox').item.json.address }}/messages?limit=10&offset=0
• Authentication: same as before

This endpoint returns immediately with an array of messages, or an empty array [] if nothing has arrived yet. Wire it into an IF node: if the array is empty, loop back to the Wait node and try again after a few seconds. If it has items, proceed.

[Wait 5s] → [GET messages] → [IF empty?] → yes: loop back / no: continue

Option B — Webhooks (Pro plan, $19/month)

This is the cleaner approach. Instead of polling, UCT pushes a notification to your n8n workflow the moment an email arrives.

First, register your webhook once (you can do this from a separate setup workflow or via Postman):

POST https://uncorreotemporal.com/api/v1/webhooks/
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "url": "https://your-n8n-instance.com/webhook/uct-inbox",
  "events": ["email.received"],
  "secret": "your-optional-signing-secret"
}

Then, in your main workflow, replace the polling loop with an n8n Webhook trigger node pointed at the same URL. When UCT fires, your workflow receives this payload:

{
  "event": "email.received",
  "inbox_id": "uuid-of-inbox",
  "message_id": "uuid-of-message",
  "from": "noreply@target-service.com",
  "subject": "Verify your email",
  "received_at": "2026-06-25T10:30:00+00:00"
}

Note that the webhook payload contains metadata only — not the email body. You’ll need one extra step to fetch the content.

Important: UCT signs every webhook request with X-UCT-Signature: sha256=<hmac_hex> using your secret. In n8n, you can verify this in a Code node before processing — good practice if your webhook URL is public.

UCT retries failed webhook deliveries 3 times with exponential backoff (5s → 30s → 5min). If all three fail, the webhook is automatically disabled.

Node 4: Fetch the Email Body

Whether you used polling or webhooks, you now have a message_id. Use it to fetch the full message:

• Method: GET
• URL: https://uncorreotemporal.com/api/v1/mailboxes/{{ $('Create Inbox').item.json.address }}/messages/{{ $json.message_id }}
• Authentication: same as before

The response includes the full email body in plain text and HTML.

Node 5: Extract the OTP

Use a Code node to parse the OTP from the body:

const body = $input.item.json.body_text;
const match = body.match(/\b\d{6}\b/);
return [{ json: { otp: match ? match[0] : null } }];

Adjust the regex for your specific case — 4-digit codes, 8-digit codes, or magic links all follow the same pattern with minor tweaks.

Node 6: Use the OTP

Submit the code. Another HTTP Request node:

• Method: POST
• URL: [https://target-service.com/api/verify](https://target-service.com/api/verify)
• Body: { "email": "...", "code": "{{ $('Extract OTP').item.json.otp }}" }

At this point, the account is verified and the workflow can continue.

Cleanup: Delete the Inbox When You’re Done

Once the workflow has what it needs, delete the inbox to keep things tidy:

• Method: DELETE
• URL: https://uncorreotemporal.com/api/v1/mailboxes/{{ $('Create Inbox').item.json.address }}

Returns 204 No Content. UCT does a soft-delete — the inbox is deactivated but messages are preserved internally.

Handling Edge Cases

What if the email is slow? Increase the polling interval or simply let your loop run more iterations. There’s no timeout on the messages endpoint — it always returns immediately with whatever exists.

What if you need a verification link instead of an OTP? The email body will contain it. Adjust your Code node to extract URLs instead of numeric codes:

const body = $input.item.json.body_text;
const match = body.match(/https?:\/\/[^\s"<>]+confirm[^\s"<>]*/i);
return [{ json: { link: match ? match[0] : null } }];

What about parallel runs? Because each execution creates its own inbox, parallel runs are completely isolated. Ten simultaneous workflow executions mean ten separate inboxes — no cross-contamination.

WebSocket for real-time without webhooks? UCT also exposes a WebSocket endpoint at WS /ws/inbox/{address}?api_key=YOUR_KEY that emits {"event": "new_message", "message_id": "uuid"} the moment an email arrives. n8n doesn't have a native WebSocket trigger, but you can use this from a companion script if you need sub-second latency on the Builder plan.

Which Plan Do You Need?

Need Plan Price Just testing the concept Free $0 Polling-based workflows, API access Builder $5/month Webhook-driven workflows Pro $19/month

For most n8n use cases — especially if you’re building internal tools or running workflows on a schedule — the Builder plan at $5/month covers everything you need. Webhooks are a nice upgrade if you’re building production pipelines where latency matters.

What You Can Build With This — And How Much of It

Here’s the number that should make you stop scrolling: the Builder plan has no monthly cycle limit.

The only real constraint is 5 concurrent inboxes. But since each inbox is freed the moment you delete it, you can reuse those 5 slots as fast as your workflow runs. Create, use, delete, repeat — indefinitely.

What does that mean in practice?

Lead generation pipelines that auto-register for competitor trial accounts to monitor features and pricing. One n8n workflow running in a loop, 5 inboxes rotating, processing registrations back to back. In a single month you could map the onboarding flow of hundreds of SaaS products — pricing pages, feature sets, email sequences — without touching a single one manually. For $5.

Price monitoring on platforms that require account verification to access member-only pricing or gated catalogues. Set your workflow to run every hour. With 5 concurrent inboxes you can monitor 5 platforms simultaneously, around the clock, 30 days straight. That’s 3,600 data points per platform per month. A professional market research firm would charge thousands for that. You’re paying $5.

Research workflows that sign up for newsletters, content gates, or invite-only communities and funnel every email into a Notion database or Google Sheet. Academic papers behind registration walls, industry reports, competitor newsletters — all flowing into your workspace automatically. Unlimited signups, $5/month.

Testing and QA automation for your own products. Every time your CI pipeline runs, spin up a fresh verified account, run the full onboarding flow, assert the verification email arrived and contains the right content, then delete the inbox. Clean, isolated, repeatable — and since the inbox slots are reusable, you can run your test suite as many times as you want without ever hitting a wall.

Multi-account workflows for platforms that allow multiple accounts per organization. Five inboxes in parallel means five accounts being created and verified simultaneously. Need 50 accounts? Run 10 batches. The workflow handles all of it while you do something else.

The constraint isn’t the tool. It’s your imagination — and apparently, your imagination only costs $5/month.

Getting Started

UnCorreoTemporal has a free tier with 3 inboxes and 20 requests/day — enough to build and test this workflow before committing to a paid plan. Head to uncorreotemporal.com to create an account and grab your API key.

If you build something interesting with this, share it — the n8n community templates section is a good place to publish a workflow JSON that others can import directly.

Email verification doesn’t have to be the step where your automation hands control back to a human. With a programmable inbox, it’s just another API call.

Have questions about this workflow? Drop them in the comments — happy to help you adapt the pattern for your specific use case.