简体中文
English
Website review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is testmail.app?
testmail.app is an email testing service for developers and QA teams. It gives you disposable inboxes you can create programmatically, so automated tests can trigger real emails—signup confirmations, password resets, transactional messages—and then retrieve them via API instead of checking a human mailbox.
How it works
You get a namespace at signup, and any address of the form {namespace}.{tag}@inbox.testmail.app becomes a real, working inbox. The {tag} is arbitrary, so you can spin up unlimited distinct addresses just by changing it—one per test run, per user, or per scenario. testmail.app receives, parses, spam-scores, and indexes each message, then exposes it through a JSON or GraphQL API. Because you query over HTTP, it fits into any language or CI/CD pipeline.
What you get
- Unlimited addresses and mailboxes from a single namespace
- JSON and GraphQL APIs, plus an interactive GraphQL playground
- Live queries that wait for a new email to arrive, useful when a test must block until delivery
- Search with wildcard matching, sorting, pagination, and attachment retrieval
- SpamAssassin reports if deliverability or spam scoring matters to you
- Team collaboration: invite members, share namespaces and test emails, manage keys and usage
Who it suits
It is aimed at engineering teams writing end-to-end or integration tests, and at anyone who needs to verify email content and headers without risking a send to a real customer. The free tier covers a modest monthly volume, which is enough to evaluate the workflow; heavier CI usage will need a paid plan. Support is handled by engineers rather than bots, and the service advertises a 99.99% uptime SLA with a public status page.
A practical next step
If you are evaluating it, start with one real test: create a namespace, point your signup flow at a tagged address, and write a live query that waits for the confirmation email and asserts on its subject and link. That single test tells you more about fit than reading the docs. If your needs are broader than email—SMS, multiple channels—compare against a wider testing platform before committing.
How do I set up testmail.app for automated email testing in my CI/CD pipeline?
Testmail.app fits CI/CD email testing by giving you disposable inboxes you can generate from a tag, then query by API instead of clicking through a mail client.
The basic setup
- Sign up and get your
namespaceand API key. The free plan covers 100 emails/month, which is enough for a small suite or a trial run. - Build test addresses from the pattern
{namespace}.{tag}@inbox.testmail.app. The tag is arbitrary, so each test run, user ID, or parallel worker can get its own address. - In your pipeline, trigger the app action that sends the email (signup, password reset, receipt).
- Query testmail.app's JSON or GraphQL API for messages matching that tag, then assert on subject, body, links, or attachments.
- Store the API key as a CI secret and pass it in as an environment variable, the same way you handle other service credentials.
A minimal flow in a CI job might look like:
# after triggering the signup
curl -s "https://api.testmail.app/api/json?apikey=$TESTMAIL_KEY&namespace=$NS&tag=ci-run-42" \
| jq '.emails[0].subject'
Practical choices
- Tag strategy: use one tag per test or per worker so parallel jobs do not read each other's mail. A timestamp or CI build number makes cleanup and debugging easier.
- Polling vs. live queries: polling with a short retry loop is simple and portable. Live queries that wait for a new email reduce flakiness when delivery is slow, but they tie the test to the API's timeout behavior.
- What to assert: prefer content that your app controls (subject line, template variables, links) over delivery metadata. SpamAssassin reports are useful when you are testing deliverability rather than correctness.
- Language: any HTTP or GraphQL client works, so use whatever your test stack already uses.
Trade-offs
Testmail.app is a receiving and inspection service, not a sending service. You still need your app or an SMTP provider to send the mail. The free tier's monthly email cap will bite if you run large suites frequently; teams with heavy test volume should check the paid plans. Because addresses are public in form, never route real customer email through them.
For a concrete scenario: a QA engineer running Playwright tests in GitHub Actions can give each spec file a unique tag, trigger signup, poll for the welcome email, extract the confirmation link, and complete the flow, all without a shared inbox or manual cleanup.
Next step: read the quickstart and API reference at Testmail.app, then run one pipeline job with a single tag before expanding to parallel workers. If you need broader email-testing tooling comparisons, Mailtrap and MailHog cover related ground, though their models differ.
What are the differences between the free plan and paid plans, and what are the email limits?
The free plan is a real, ongoing tier rather than a trial: it includes unlimited email addresses and mailboxes, but caps you at 100 emails per month. Paid plans are where higher email volume, team management at scale, and the 99.99% uptime SLA live. The page does not publish the exact paid tiers or their monthly email allowances, so check testmail.app pricing for current numbers before you commit.
How the limits actually work
- Mailboxes are never the constraint. Every plan lets you create addresses on the fly by changing the tag in
{namespace}.{tag}@inbox.testmail.app, so each tag is effectively a new mailbox. You will not run out of addresses on the free tier. - Emails received are the constraint. The 100/month figure counts messages the service receives, parses, spam-tests and indexes for retrieval. A signup flow that fires a welcome email, a verification email and a receipt burns three of them.
- Free is fine for one developer on one project. A single end-to-end signup test run a few times a day stays comfortably inside 100. A CI pipeline running the full suite on every pull request will not.
- Paid is about throughput and team structure. Higher volume, plus separate namespaces per project and the enterprise option of managing multiple distinct teams. Collaborator invites are free on all plans, so adding teammates is not itself a reason to upgrade.
A quick way to decide
Estimate your monthly test emails: number of test runs × emails per run × working days. If that lands under roughly 80, stay free and keep headroom. If it is over, or if two or more projects need isolated namespaces, price the paid tier against the cost of a flaky test suite.
One practical note: because tags are arbitrary, use a naming scheme like {project}-{branch}-{runid} from day one. It costs nothing and makes wildcard searches and live queries far easier when you do scale up.
How does testmail.app help prevent sending test emails to real customers?
testmail.app prevents accidental sends to real customers by giving every test message a destination that only exists inside its own system. Instead of pointing a staging or test build at a real customer address, you send to a generated address in the form {namespace}.{tag}@inbox.testmail.app. Because the {tag} can be any string, each tag creates a separate, real deliverable mailbox on the fly — so your code can generate unlimited unique test addresses without touching a live inbox.
The service receives, parses, spam-tests, and indexes those messages, then exposes them through a JSON or GraphQL API. Your tests (or CI/CD pipeline) query the API to confirm the email arrived and inspect its contents. The practical benefit is that test traffic never leaves this sandbox, so a misconfigured recipient list, a hard-coded staging address, or a copy-paste error cannot reach a customer's inbox.
What this looks like in practice
- Signup and verification flows: Your end-to-end test registers a user with
[email protected], triggers the welcome or verification email, then queries the API for that tag to assert the subject, body, and links. - Transactional emails: Order confirmations, password resets, and receipts can be checked with "live" queries that wait for a new message, plus sorting, pagination, wildcard search, and attachment retrieval.
- Deliverability checks: SpamAssassin reports let you see how a message scores before it ever goes to a real recipient.
- Team workflows: You can invite collaborators at no extra cost, create separate namespaces per project, and share test emails or API keys securely. The page also notes a free forever tier with 100 emails per month and no credit card required.
Trade-offs and a decision criterion
The main limitation is that this is a testing sandbox, not a real mail provider: it validates that your application sent the right message, not that a customer's mailbox provider will accept it. For inbox placement at major providers, you still need seed-list or real-account testing. Also, because tags are effectively public address components, avoid putting sensitive production data in test emails.
Use testmail.app when your risk is "our test suite emailed a real person" or "we can't verify email content automatically in CI." If your risk is "Gmail is marking us as spam," pair it with a dedicated deliverability tool. To start, sign up, grab a namespace and API key, then replace hard-coded test recipients with generated {namespace}.{tag}@inbox.testmail.app addresses in your test fixtures. The official documentation at testmail.app covers the API reference and an interactive GraphQL playground.
Can I use testmail.app with any programming language or HTTP client, and how do I query emails via the API?
Yes. testmail.app is designed to be language- and client-agnostic: you send test emails to an address it generates and then retrieve them over HTTP, so anything that can make a web request can use it.
How the address works
testmail.app gives you a namespace, and every address follows this pattern:
{namespace}.{tag}@inbox.testmail.app
The tag is arbitrary. Each unique tag creates a separate real mailbox, so you can generate unlimited addresses in a test simply by changing the tag — useful for giving each test run, user, or CI job its own inbox.
Querying emails via the API
The flow is: send a test email to a generated address, then call the API to fetch and parse it.
- JSON API — a simple REST-style endpoint for retrieving emails.
- GraphQL API — a more expressive query interface, with an interactive GraphQL Playground for testing queries.
- Any HTTP or GraphQL client — use whatever your language or environment provides, including CI/CD pipelines.
Query features the product highlights include wildcard search, "live" queries that wait for new emails, sorting, pagination, attachment handling, and SpamAssassin spam reports.
Typical example
A signup test might look like this:
- Build the address
[email protected]. - Submit your app's signup form with that address.
- Query the API filtered by that tag.
- Assert on the subject, body, links, or spam score.
Next step
Get your namespace and API key, read the quickstart and API reference, then try queries in the GraphQL Playground before wiring them into your test suite. See testmail.app.
Decision criterion
Choose the JSON API for straightforward fetch-and-assert steps; choose GraphQL when you need combined filters, wildcard matching, or live waits. Either way, the deciding factor is usually whether your test runner can block on a request until the email arrives.
How does testmail.app handle team collaboration and what security measures are in place?
testmail.app handles team collaboration through shared namespaces, email-based invitations, and per-project separation, while its security model rests on forced HTTPS/TLS, encryption in transit and at rest, passwordless logins, and a claimed 99.99% uptime SLA.
H3 Collaboration
- Invite team members by email; collaborators can share test emails, mailboxes, and namespaces.
- Create separate namespaces per project so teams don't mix test data.
- Provision and retrieve API keys per namespace, so credentials can be scoped rather than shared globally.
- Monitor usage and manage team membership from the same interface.
- The page states collaborators are unlimited on all plans at no extra cost; multiple separate teams are positioned as an enterprise feature.
H3 Security and reliability
- HTTPS/TLS is forced on all traffic.
- Data is encrypted in transit and at rest.
- Logins are passwordless.
- APIs are distributed across multiple data centers with around-the-clock monitoring.
- A public status page provides real-time uptime checks, and the page cites a 99.99% uptime SLA tied to paid plans.
H3 Practical takeaway
For a small QA team, the namespace-per-project model is the main collaboration win: each tester can generate addresses like {namespace}.{tag}@inbox.testmail.app without stepping on a colleague's inbox. The trade-off is that namespace access is the real security boundary, so treat namespace API keys like production secrets and rotate them when someone leaves. If you need isolated teams rather than one shared account, the enterprise tier is the stated path.
Next step: read the official docs and pricing page to confirm current plan limits before standardizing your CI pipeline on it. See testmail.app and testmail.app pricing.
Cloudflare
Google Workspace
User reviews (0)