Quickstart
From nothing to your first captured email, in about two minutes. The credentials below are live and already yours — no sign-up, no project to create first.
Your sandbox
Live credentials, filled into every snippet on this page as soon as they arrive.
- Host
- smtp.mailclutch.com
- Port
- 587
- Username
- mc_0000000000000000
- Password
- pw_0000000000000000
1. Point your app at the sandbox
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
# .env MAIL_MAILER=smtp MAIL_HOST=smtp.mailclutch.com MAIL_PORT=587 MAIL_USERNAME=mc_0000000000000000 MAIL_PASSWORD=pw_0000000000000000 MAIL_FROM_ADDRESS="staging@example.com" MAIL_FROM_NAME="${APP_NAME}"
Then php artisan config:clear, or the cached values keep being used.
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
# .env.local MAILER_DSN=smtp://mc_0000000000000000:pw_0000000000000000@smtp.mailclutch.com:587
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
# settings.py EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend' EMAIL_HOST = 'smtp.mailclutch.com' EMAIL_PORT = 587 EMAIL_HOST_USER = 'mc_0000000000000000' EMAIL_HOST_PASSWORD = 'pw_0000000000000000' EMAIL_USE_TLS = True DEFAULT_FROM_EMAIL = 'staging@example.com'
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
# config/environments/development.rb config.action_mailer.delivery_method = :smtp config.action_mailer.perform_deliveries = true config.action_mailer.raise_delivery_errors = true config.action_mailer.smtp_settings = { address: 'smtp.mailclutch.com', port: 587, user_name: 'mc_0000000000000000', password: 'pw_0000000000000000', authentication: :plain, enable_starttls_auto: true }
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
import nodemailer from 'nodemailer'; export const mailer = nodemailer.createTransport({ host: 'smtp.mailclutch.com', port: 587, secure: false, // STARTTLS is negotiated after connecting auth: { user: 'mc_0000000000000000', pass: 'pw_0000000000000000', }, });
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
# .env.local SMTP_HOST=smtp.mailclutch.com SMTP_PORT=587 SMTP_USER=mc_0000000000000000 SMTP_PASSWORD=pw_0000000000000000
No NEXT_PUBLIC_ prefix: a prefixed variable is inlined into the client bundle.
Go takes the four values where it builds its client. The snippet below is a whole program — the pair from the card above, and one message on its way.
package main import ( "fmt" "net/smtp" ) func main() { host := "smtp.mailclutch.com" auth := smtp.PlainAuth("", "mc_0000000000000000", "pw_0000000000000000", host) msg := []byte("To: anyone@example.com\r\n" + "From: staging@example.com\r\n" + "Subject: Sandbox check\r\n" + "\r\n" + "Hello from Go.\r\n") err := smtp.SendMail( fmt.Sprintf("%s:%d", host, 587), auth, "staging@example.com", []string{"anyone@example.com"}, msg, ) if err != nil { panic(err) } }
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
spring.mail.host=smtp.mailclutch.com spring.mail.port=587 spring.mail.username=mc_0000000000000000 spring.mail.password=pw_0000000000000000 spring.mail.properties.mail.smtp.auth=true spring.mail.properties.mail.smtp.starttls.enable=true
The starter itself is one dependency — spring-boot-starter-mail.
Java takes the four values where it builds its client. The snippet below is a whole program — the pair from the card above, and one message on its way.
Properties props = new Properties(); props.put("mail.smtp.host", "smtp.mailclutch.com"); props.put("mail.smtp.port", "587"); props.put("mail.smtp.auth", "true"); props.put("mail.smtp.starttls.enable", "true"); Session session = Session.getInstance(props, new Authenticator() { @Override protected PasswordAuthentication getPasswordAuthentication() { return new PasswordAuthentication("mc_0000000000000000", "pw_0000000000000000"); } }); Message message = new MimeMessage(session); message.setFrom(new InternetAddress("staging@example.com")); message.setRecipients(Message.RecipientType.TO, InternetAddress.parse("anyone@example.com")); message.setSubject("Sandbox check"); message.setText("Hello from Java."); Transport.send(message);
.NET takes the four values where it builds its client. The snippet below is a whole program — the pair from the card above, and one message on its way.
using MailKit.Net.Smtp; using MailKit.Security; using MimeKit; var message = new MimeMessage(); message.From.Add(MailboxAddress.Parse("staging@example.com")); message.To.Add(MailboxAddress.Parse("anyone@example.com")); message.Subject = "Sandbox check"; message.Body = new TextPart("html") { Text = "<h1>Hello from .NET</h1>" }; using var client = new SmtpClient(); await client.ConnectAsync("smtp.mailclutch.com", 587, SecureSocketOptions.StartTls); await client.AuthenticateAsync("mc_0000000000000000", "pw_0000000000000000"); await client.SendAsync(message); await client.DisconnectAsync(true);
If your application reads its mail settings from configuration, the same four values go in appsettings.Development.json — the .NET guide has that block.
PHP takes the four values where it builds its client. The snippet below is a whole program — the pair from the card above, and one message on its way.
<?php use PHPMailer\PHPMailer\PHPMailer; require 'vendor/autoload.php'; $mail = new PHPMailer(true); $mail->isSMTP(); $mail->Host = 'smtp.mailclutch.com'; $mail->Port = 587; $mail->SMTPAuth = true; $mail->Username = 'mc_0000000000000000'; $mail->Password = 'pw_0000000000000000'; $mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS; $mail->setFrom('staging@example.com'); $mail->addAddress('anyone@example.com'); $mail->Subject = 'Sandbox check'; $mail->isHTML(true); $mail->Body = '<h1>Hello from PHP</h1>'; $mail->send();
Python takes the four values where it builds its client. The snippet below is a whole program — the pair from the card above, and one message on its way.
import smtplib from email.message import EmailMessage message = EmailMessage() message['From'] = 'staging@example.com' message['To'] = 'anyone@example.com' message['Subject'] = 'Sandbox check' message.set_content('Hello from Python.') with smtplib.SMTP('smtp.mailclutch.com', 587) as smtp: smtp.starttls() smtp.login('mc_0000000000000000', 'pw_0000000000000000') smtp.send_message(message)
Rust takes the four values where it builds its client. The snippet below is a whole program — the pair from the card above, and one message on its way.
use lettre::transport::smtp::authentication::Credentials; use lettre::{Message, SmtpTransport, Transport}; fn main() -> Result<(), Box<dyn std::error::Error>> { let email = Message::builder() .from("staging@example.com".parse()?) .to("anyone@example.com".parse()?) .subject("Sandbox check") .body(String::from("Hello from Rust."))?; let credentials = Credentials::new( "mc_0000000000000000".to_owned(), "pw_0000000000000000".to_owned(), ); let mailer = SmtpTransport::starttls_relay("smtp.mailclutch.com")? .port(587) .credentials(credentials) .build(); mailer.send(&email)?; Ok(()) }
Nothing to configure: cURL takes the credentials on the command line, so step 2 is the whole setup.
Nothing to configure: swaks takes the credentials on the command line, so step 2 is the whole setup.
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
# ~/.msmtprc account sandbox host smtp.mailclutch.com port 587 auth on user mc_0000000000000000 password pw_0000000000000000 from staging@example.com tls on tls_starttls on account default : sandbox
msmtp refuses to run if anyone else can read the file — chmod 600 ~/.msmtprc.
Nothing to configure: PowerShell takes the credentials on the command line, so step 2 is the whole setup.
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
# /etc/postfix/main.cf relayhost = [smtp.mailclutch.com]:587 smtp_sasl_auth_enable = yes smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd smtp_sasl_security_options = noanonymous smtp_tls_security_level = encrypt
# /etc/postfix/sasl_passwd [smtp.mailclutch.com]:587 mc_0000000000000000:pw_0000000000000000
Then sudo postmap /etc/postfix/sasl_passwd and reload Postfix. The host and port must match relayhost character for character, brackets included.
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
# docker-compose.yml services: app: environment: SMTP_HOST: smtp.mailclutch.com SMTP_PORT: "587" SMTP_USER: mc_0000000000000000 SMTP_PASSWORD: pw_0000000000000000
Use the names your application already reads — MAIL_HOST, EMAIL_HOST, and so on.
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
// wp-config.php — above "That's all, stop editing!" define( 'WPMS_ON', true ); define( 'WPMS_MAILER', 'smtp' ); define( 'WPMS_SMTP_HOST', 'smtp.mailclutch.com' ); define( 'WPMS_SMTP_PORT', 587 ); define( 'WPMS_SSL', 'tls' ); define( 'WPMS_SMTP_AUTH', true ); define( 'WPMS_SMTP_USER', 'mc_0000000000000000' ); define( 'WPMS_SMTP_PASS', 'pw_0000000000000000' );
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
# /etc/gitlab/gitlab.rb gitlab_rails['smtp_enable'] = true gitlab_rails['smtp_address'] = "smtp.mailclutch.com" gitlab_rails['smtp_port'] = 587 gitlab_rails['smtp_user_name'] = "mc_0000000000000000" gitlab_rails['smtp_password'] = "pw_0000000000000000" gitlab_rails['smtp_authentication'] = "login" gitlab_rails['smtp_enable_starttls_auto'] = true gitlab_rails['gitlab_email_from'] = 'staging@example.com'
Then sudo gitlab-ctl reconfigure.
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
# grafana.ini [smtp] enabled = true host = smtp.mailclutch.com:587 user = mc_0000000000000000 password = pw_0000000000000000 from_address = staging@example.com from_name = Grafana
In a container, the same settings are the GF_SMTP_* environment variables. Restart Grafana for the change to take.
Replace the mail settings of your staging or development environment with the block below. Nothing else changes: Mailclutch is a normal SMTP server, and the username and password are the ones from the card above.
"smtpServer": { "host": "smtp.mailclutch.com", "port": "587", "starttls": "true", "auth": "true", "user": "mc_0000000000000000", "password": "pw_0000000000000000", "from": "staging@example.com" }
Or fill in Realm settings → Email by hand: the same host, port, StartTLS on, authentication on.
Ports 25, 465, 587, 2525 all work — STARTTLS everywhere except 465, which is implicit TLS. Every stack in the selector has a guide of its own, with what to install and what usually goes wrong.
2. Send an email
Trigger any email from your application — a signup, a password reset, your test suite. Or send one from Laravel directly:
Mail::raw('Hello from Laravel.', function ($message) { $message->to('anyone@example.com')->subject('Sandbox check'); });
Trigger any email from your application — a signup, a password reset, your test suite. Or send one from Symfony directly:
php bin/console mailer:test anyone@example.comTrigger any email from your application — a signup, a password reset, your test suite. Or send one from Django directly:
python manage.py sendtestemail anyone@example.comTrigger any email from your application — a signup, a password reset, your test suite. Or send one from Rails directly:
ActionMailer::Base.mail( from: 'staging@example.com', to: 'anyone@example.com', subject: 'Sandbox check', body: 'Hello from Rails.' ).deliver_now
Trigger any email from your application — a signup, a password reset, your test suite. Or send one from Node.js directly:
await mailer.sendMail({ from: 'staging@example.com', to: 'anyone@example.com', subject: 'Sandbox check', html: '<h1>Hello from Node.js</h1>', });
Trigger any email from your application — a signup, a password reset, your test suite. Or send one from Next.js directly:
// app/api/send/route.ts import nodemailer from 'nodemailer'; export async function POST() { const transporter = nodemailer.createTransport({ host: process.env.SMTP_HOST, port: Number(process.env.SMTP_PORT), auth: { user: process.env.SMTP_USER, pass: process.env.SMTP_PASSWORD, }, }); await transporter.sendMail({ from: 'staging@example.com', to: 'anyone@example.com', subject: 'Sandbox check', html: '<h1>Hello from Next.js</h1>', }); return Response.json({ sent: true }); }
The snippet above is a whole program: run it, and the message is on its way. If you would rather not touch the project yet, send one straight from a terminal:
swaks --server smtp.mailclutch.com --port 587 -tls \ --auth LOGIN \ --auth-user "mc_0000000000000000" \ --auth-password "pw_0000000000000000" \ --from staging@example.com \ --to anyone@example.com \ --header "Subject: Sandbox check" \ --body "Hello from the quickstart."
Trigger any email from your application — a signup, a password reset, your test suite. Or send one from Spring directly:
@Autowired private JavaMailSender mailSender; public void sendTest() { SimpleMailMessage message = new SimpleMailMessage(); message.setFrom("staging@example.com"); message.setTo("anyone@example.com"); message.setSubject("Sandbox check"); message.setText("Hello from Spring Boot."); mailSender.send(message); }
The snippet above is a whole program: run it, and the message is on its way. If you would rather not touch the project yet, send one straight from a terminal:
swaks --server smtp.mailclutch.com --port 587 -tls \ --auth LOGIN \ --auth-user "mc_0000000000000000" \ --auth-password "pw_0000000000000000" \ --from staging@example.com \ --to anyone@example.com \ --header "Subject: Sandbox check" \ --body "Hello from the quickstart."
The snippet above is a whole program: run it, and the message is on its way. If you would rather not touch the project yet, send one straight from a terminal:
swaks --server smtp.mailclutch.com --port 587 -tls \ --auth LOGIN \ --auth-user "mc_0000000000000000" \ --auth-password "pw_0000000000000000" \ --from staging@example.com \ --to anyone@example.com \ --header "Subject: Sandbox check" \ --body "Hello from the quickstart."
The snippet above is a whole program: run it, and the message is on its way. If you would rather not touch the project yet, send one straight from a terminal:
swaks --server smtp.mailclutch.com --port 587 -tls \ --auth LOGIN \ --auth-user "mc_0000000000000000" \ --auth-password "pw_0000000000000000" \ --from staging@example.com \ --to anyone@example.com \ --header "Subject: Sandbox check" \ --body "Hello from the quickstart."
The snippet above is a whole program: run it, and the message is on its way. If you would rather not touch the project yet, send one straight from a terminal:
swaks --server smtp.mailclutch.com --port 587 -tls \ --auth LOGIN \ --auth-user "mc_0000000000000000" \ --auth-password "pw_0000000000000000" \ --from staging@example.com \ --to anyone@example.com \ --header "Subject: Sandbox check" \ --body "Hello from the quickstart."
The snippet above is a whole program: run it, and the message is on its way. If you would rather not touch the project yet, send one straight from a terminal:
swaks --server smtp.mailclutch.com --port 587 -tls \ --auth LOGIN \ --auth-user "mc_0000000000000000" \ --auth-password "pw_0000000000000000" \ --from staging@example.com \ --to anyone@example.com \ --header "Subject: Sandbox check" \ --body "Hello from the quickstart."
One command, and the message is in the sandbox — the credentials are the whole configuration:
This one pipes our sample message in, so the inbox has something worth looking at.
curl -fsS https://app.mailclutch.com/welcome.eml | curl "smtp://smtp.mailclutch.com:587" --ssl-reqd \ --user "mc_0000000000000000:pw_0000000000000000" \ --mail-from "staging@example.com" \ --mail-rcpt "anyone@example.com" \ --upload-file -
One command, and the message is in the sandbox — the credentials are the whole configuration:
swaks --server smtp.mailclutch.com --port 587 -tls \ --auth LOGIN \ --auth-user "mc_0000000000000000" \ --auth-password "pw_0000000000000000" \ --from staging@example.com \ --to anyone@example.com \ --header "Subject: Sandbox check" \ --body "Hello from swaks."
Trigger any email from your application — a signup, a password reset, your test suite. Or send one from msmtp directly:
printf 'Subject: Sandbox check\n\nHello from msmtp.\n' | msmtp anyone@example.comOne command, and the message is in the sandbox — the credentials are the whole configuration:
$password = ConvertTo-SecureString "pw_0000000000000000" -AsPlainText -Force $credential = New-Object System.Management.Automation.PSCredential("mc_0000000000000000", $password) Send-MailMessage -SmtpServer "smtp.mailclutch.com" -Port 587 -UseSsl ` -Credential $credential ` -From "staging@example.com" ` -To "anyone@example.com" ` -Subject "Sandbox check" ` -Body "<h1>Hello from PowerShell</h1>" -BodyAsHtml
Trigger any email from your application — a signup, a password reset, your test suite. Or send one from Postfix relay directly:
echo "Hello from Postfix." | mail -s "Sandbox check" anyone@example.comTrigger any email from the application you just pointed here. Or send one straight from a terminal:
swaks --server smtp.mailclutch.com --port 587 -tls \ --auth LOGIN \ --auth-user "mc_0000000000000000" \ --auth-password "pw_0000000000000000" \ --from staging@example.com \ --to anyone@example.com \ --header "Subject: Sandbox check" \ --body "Hello from the quickstart."
Trigger any email from your application — a signup, a password reset, your test suite. Or send one from WordPress directly:
WP Mail SMTP has an Email Test tab of its own. Or, from WP-CLI:
wp eval "wp_mail( 'anyone@example.com', 'Sandbox check', 'Hello from WordPress.' );"Trigger any email from your application — a signup, a password reset, your test suite. Or send one from GitLab directly:
# sudo gitlab-rails console Notify.test_email('anyone@example.com', 'Sandbox check', 'Hello from GitLab.').deliver_now
Alerting → Contact points → the email contact point → Test. The message lands in the sandbox with the template it would really use.
Or, to prove the credentials on their own, send one straight from a terminal:
swaks --server smtp.mailclutch.com --port 587 -tls \ --auth LOGIN \ --auth-user "mc_0000000000000000" \ --auth-password "pw_0000000000000000" \ --from staging@example.com \ --to anyone@example.com \ --header "Subject: Sandbox check" \ --body "Hello from the quickstart."
The Email tab has a Test connection button, which sends to the address on your own account.
Or, to prove the credentials on their own, send one straight from a terminal:
swaks --server smtp.mailclutch.com --port 587 -tls \ --auth LOGIN \ --auth-user "mc_0000000000000000" \ --auth-password "pw_0000000000000000" \ --from staging@example.com \ --to anyone@example.com \ --header "Subject: Sandbox check" \ --body "Hello from the quickstart."
The address in the To: field is arbitrary and safe: the credentials pick the inbox, and the message is never relayed to the real recipient.
3. Open the inbox
The email is there — rendered HTML, plain text, raw source, headers, attachments, and the SPF, DKIM and DMARC verdicts. It updates live, so you can leave the tab open next to your terminal.
Your sandbox is waiting.Opens in a new tab, on the credentials above. It keeps what it catches for 24 hours.
4. Keep it
A sandbox is temporary on purpose. Claim it with an account within 7 days and everything in it stays, in a real project.
Sign up and you get an organization and one project. A project is an isolated inbox: create one per client, or one per environment — whichever way you divide your work. Each has its own SMTP username and password, shown on the project page; they are not your account password, and revoking a project revokes them.
The Free plan allows 2 projects and keeps captured email for 7 days. Paid plans lift both limits and add the analysis tab, which scores SPF, DKIM, DMARC, BIMI, List-Unsubscribe and SpamAssassin.
Need someone else to look at an email? Share it — or the whole project — as a link. The person opening it needs no account and takes no seat.
No SMTP? Use the address instead
Every project also has its own address at @mailclutch.com. Anything sent to it lands in the project, which is handy for tools you can't reconfigure.