Real SMTP infrastructure — not mocked

Inboxes that respond
to your code and your mail

MailFork gives you programmable inboxes — create, route, extract, and expire via SDK. And agentic inboxes — react when mail arrives, push OTPs, and trigger workflows automatically. All on real SMTP.

ci+run-8f3a@qa.acme.mailfork.dev programmable
[email protected] agentic
Start for free Read the docs
Programmable

Your code drives the inbox

Create aliases per test run, extract OTPs with one SDK call, and clean up automatically. Your tests stay in control — no polling loops, no manual steps.

  • Alias per CI job — no test pollution between parallel runs
  • extractOtp() — no regex, no waiting, just the code
  • TTL + on_expire: delete — auto-cleanup on teardown
  • TypeScript + Python SDK with full type coverage
Agentic
On request

The inbox acts — you just watch

Attach a webhook to any inbox. When mail arrives, MailFork extracts the OTP, matches your rules, and POSTs the payload to your endpoint — no polling required.

  • Webhook on delivery — fires the instant mail arrives
  • Push OTP extraction — payload includes the code, pre-extracted
  • Rule filters — match by from, subject, or alias tag
  • Retry with backoff — reliable delivery to your endpoint
Programmable

Write tests,
not inbox management code

The SDK handles address creation, polling, OTP extraction, and cleanup. Your test creates the alias, triggers the flow, reads the code, and moves on.

  • Typed SDK for TypeScript and JavaScript
  • Built-in polling with configurable timeout
  • Alias auto-expiry with delete or keep semantics
  • REST API for any language or CI environment
otp-test.ts 
// create a one-time alias for this test run
const alias = await mf.inboxes.createAlias(INBOX_ID, {
  tag: `run-${Date.now()}`,
  ttl_hours: 1,
  on_expire: 'delete',
});

// trigger the signup email in your app
await page.goto(`/signup?email=ci+${alias.tag}@qa.acme.mailfork.dev`);

// extract the OTP — no regex needed
const otp = await mf.emails.extractOtp(INBOX_ID, { alias_tag: alias.tag });
await page.fill('#otp-input', otp);
webhook-payload.json
On request 
// MailFork POSTs this to your endpoint on delivery
{
  "event": "email.received",
  "inbox": "[email protected]",
  "from": "[email protected]",
  "subject": "Your verification code is 847291",
  "extracted": {
    "otp": "847291",
    "links": ["https://yourapp.com/verify/..."]
  },
  "received_at": "2026-06-07T14:23:01Z"
}
Agentic — on request

Mail arrives.
Your pipeline moves.

Attach a webhook to any inbox or alias. The moment mail arrives, MailFork extracts the OTP, evaluates your rules, and delivers the payload — before your test even asks for it.

  • Zero-poll delivery — webhook fires on SMTP queue, not on request
  • OTP pre-extracted in the payload — no second API call
  • Rule filters — from, subject regex, alias tag
  • Retry with exponential backoff

One namespace.
Every team.

Your org gets a single subdomain. Teams get their own slug inside it. Adding a new team is one API call — no DNS changes, no propagation wait.

  • Shared team inbox for every member
  • Personal inboxes for each member
  • Role-based access — admin, member
  • No per-team DNS records ever
namespace.md 
# namespace hierarchy

acme.mailfork.dev
├── qa.acme.mailfork.dev          (team)
│   ├── [email protected]
│   ├── [email protected]
│   └── [email protected]
│
└── backend.acme.mailfork.dev     (team)
    └── [email protected]

# adding a team = one API call, zero DNS changes

How MailFork compares

Other tools give you inboxes. MailFork gives you infrastructure that acts.

Feature MailFork Mailosaur MailSlurp
Real SMTP (not mocked)
Programmable alias lifecycle
OTP extraction API Partial
Org + team namespace hierarchy
No DNS changes per team
TypeScript + Python SDK
Webhook push delivery On request
Native IMAP Planned

Built for these workflows

Programmable

E2E test suites

Each Playwright or Selenium run gets a fresh alias. OTP extracted in one SDK call. Alias and emails deleted on teardown — zero cleanup code.

PlaywrightSeleniumJest
Programmable

CI pipelines

Parallel jobs derive unique addresses from the run ID. No shared inbox state, no cross-run interference, no flaky email assertions.

GitHub ActionsGitLab CICircleCI
Agentic On request

Event-driven pipelines

A webhook fires the moment mail arrives. Your CI step resumes instantly — no polling loop sitting inside your build waiting for an email.

WebhooksStagingTransactional QA

Start with programmable inboxes today

Free tier includes 3 inboxes and 100 stored emails. No credit card required.

Interested in agentic webhooks? Get in touch and we'll enable it for your account.

Create free account Request agentic access