If you've ever tried to test your own signup flow, provision a demo account, or sign up for a vendor's API on behalf of your one-person company, you've hit the same wall every solo founder hits: the form submits fine, and then the service says "check your email to verify your account." Now a human has to open an inbox, find the code or the link, and come back to finish the job. That single step is why so many "fully automated" onboarding tests still have a person babysitting them.
You don't need to be an engineer to fix this. This guide shows how to build a registration bot with Claude Code — the AI coding agent — where Playwright handles the browser and email verification is solved by a temporary inbox the bot owns. You describe what you want in plain English; Claude Code writes and runs the Playwright automation and the email lookups for you. No prior coding experience required, no manual "please check your inbox" step left in the loop.
Most no-code and low-code automation tools are genuinely good at the mechanical parts of signing up for something: filling a name field, generating a password, clicking submit. Where they consistently fall apart is the moment the target service says "we sent you an email."
Three things go wrong when solo founders try to work around this without dedicated infrastructure:
Your personal inbox becomes the bottleneck. If the bot uses your real email address, you have to manually forward or copy the OTP every single time. That's not automation — that's you, with extra steps.
Shared or reused addresses get flagged. Many signup forms silently reject addresses that look reused, disposable, or machine-generated. If your bot reuses test@yourdomain.com
for every run, some services will start bouncing it after a few signups.
Reading a real inbox by code is a project of its own. Wiring up Gmail or Outlook programmatically means OAuth, token refresh, and app permissions — a serious side quest if all you wanted was to test a signup form.
The fix that professional QA teams use is the same one that works for a solo founder with no engineering background: give the bot a fresh, disposable inbox for every run, one it can create and read on its own. That's what turns "check your email" from a manual step into something Claude Code can just... do.
Here's the mental model, without any code required on your end.
Playwright is the browser automation engine. It's what actually opens a Chromium browser, navigates to the signup page, types into form fields, and clicks buttons — the same way a human would, just faster and unattended. You never touch Playwright directly; you describe the task, and Claude Code writes and runs the Playwright script behind the scenes.
The temporary email layer is what closes the loop that Playwright alone can't handle. Playwright can click "Create account," but it has no way to open an inbox and read a verification code — browsers don't have mailboxes. That's the job of the UnCorreoTemporal MCP server, which gives Claude Code a set of tools purpose-built for exactly this handoff: create_signup_inbox
, wait_for_verification_email
, extract_otp_code
, extract_verification_link
, and complete_signup_flow
.
Put together, the architecture looks like this:
You describe the task in plain English
↓
Claude Code creates a disposable inbox (create_signup_inbox)
↓
Claude Code drives Playwright to fill and submit the signup form
↓
Claude Code waits for the verification email (wait_for_verification_email)
↓
Claude Code extracts the OTP or link (extract_otp_code / extract_verification_link)
↓
Claude Code drives Playwright to enter the code or open the link
↓
Account verified — inbox expires automatically
The two pieces — Playwright for the browser, MCP for the inbox — never need to know about each other's internals. Claude Code is the one thing coordinating both, which is exactly why you can describe the whole flow in a sentence instead of writing an integration between two separate systems.
You need two things installed once: Claude Code itself, and the email MCP server. The second one is a single terminal command — you paste it in once and never think about it again:
claude mcp add uncorreotemporal \
-e UCT_API_KEY=uct_your_key_here \
-- uvx uncorreotemporal-mcp
Grab your API key from uncorreotemporal.com first — the free plan is enough to build and test a registration bot end to end. Once the server is registered, restart Claude Code and you're ready. No package installs, no config files to hand-edit.
You don't have to write the Playwright code, but seeing what Claude Code actually produces makes it much easier to trust — and to ask for changes when something isn't quite right.
When you tell Claude Code something like "Sign up for app.example.com using a temporary email, then verify the account," it first asks the email MCP server for an inbox:
Tool: create_signup_inbox
Input: { "service_name": "app.example.com" }
Output: {
"inbox_id": "mx_abc123@mail.uncorreotemporal.com",
"email": "mx_abc123@mail.uncorreotemporal.com",
"expires_at": "2026-07-15T11:30:00Z"
}
Then it writes and runs a short Playwright script to fill out the actual form — this is the part happening in the browser, invisible to you unless you ask for a screenshot:
test('register with temporary inbox', async ({ page }) => {
await page.goto('https://app.example.com/signup');
await page.fill('#email', 'mx_abc123@mail.uncorreotemporal.com');
await page.fill('#name', 'Alex Founder');
await page.fill('#password', 'TempP@ss2026!');
await page.click('button[type="submit"]');
});
With the form submitted, Claude Code switches back to the email tools and waits — this call blocks internally until the email shows up, so nothing is polling in a loop burning your time or budget:
Tool: wait_for_verification_email
Input: { "inbox_id": "mx_abc123@mail.uncorreotemporal.com", "timeout_seconds": 90 }
Output: { "status": "received", "message_id": "msg_9x2p1q", "subject": "Verify your account" }
Then it pulls the code or link out of that email:
Tool: extract_otp_code
Input: { "message_id": "msg_9x2p1q", "inbox_id": "mx_abc123@mail.uncorreotemporal.com" }
Output: { "otp_code": "847291" }
And finishes the loop by having Playwright type that code into the verification field and submit it. From the moment you typed your instruction to a verified account, nothing required you to open an inbox, copy a code, or paste anything by hand.
For the common case — one signup, one verification email — you don't even need the individual steps above. Claude Code can call a single combined tool, complete_signup_flow
, that creates the inbox, waits for the email, and extracts both the OTP and the link in one shot. Ask for the simple version first; only ask for the step-by-step breakdown if you need to filter by subject line or debug why an email isn't showing up.
This isn't just a party trick — it solves real, recurring friction for a one-person company.
Testing your own signup flow after every change. If you're building a SaaS product yourself (with AI-assisted coding, no-code tools, or a mix), you change your signup form more often than you'd like to admit. A registration bot lets you verify — in under a minute — that new users can still sign up and verify their account, without you manually creating and deleting test accounts all day.
Provisioning demo or sandbox accounts for vendors. Almost every API, payment processor, or B2B tool you evaluate as a solo founder requires its own signed-up, email-verified account. When you're comparing five vendors, that's five signup forms and five inboxes to babysit. The bot does all five while you do something else.
Onboarding QA before a launch or a marketing push. Before you send traffic to a new landing page or signup flow, you want confidence the whole path — form, email, verification — actually works. Running the bot a few times against a staging environment catches broken links or slow email delivery before your first real user does.
Recurring checks without a QA team. You don't have engineers on staff to write and maintain end-to-end tests. Describing the flow to Claude Code once, then re-running it whenever you ship a change, gets you most of the benefit of a QA process without hiring for it.
In every case, the pattern is the same: Playwright handles "act like a person filling out a form," the temporary inbox handles "receive and read the email a person would have opened," and Claude Code is the one thing tying the two together based on what you asked for in plain language.
This kind of bot is built for testing your own product, evaluating vendors, and running QA — not for creating accounts to bypass a service's free-trial limits or terms of service. Use a short-lived inbox for the specific task you're testing, not to spin up dozens of accounts on someone else's platform.
Email verification used to be the one step in a registration flow that forced a human to sit and wait. With Claude Code driving Playwright on one side and a disposable inbox on the other, that step disappears — you describe the signup once, and the bot handles the browser, the wait, and the inbox itself. If you want to try it on your own signup flow, uncorreotemporal.com has a free tier that's enough to build and run your first registration bot today.
Originally published at uncorreotemporal.com/blog/playwright-email-verification-registration-bot