SMTP
Host, port, and an API key. Every stack is on this page.
Connection
Username is always unitpost. Password is an API key with emails:send. TLS is required.
| Host | smtp.unitpost.com |
|---|---|
| Username | unitpost(always this literal value) |
| Password | Your Unitpost API key(must carry emails:send) |
| Port (STARTTLS) | 587(or 2587 if blocked, or 25) |
| Port (implicit TLS) | 465(or 2465 if blocked) |
| Security | TLS 1.2 or 1.3(required before AUTH) |
| From address | Any address on a verified domain |
Nodemailer
Nodemailer is not deprecated. Create a transport with createTransport, point it at smtp.unitpost.com on port 587 (STARTTLS) or 465 (implicit TLS), and send from a verified domain. Port 25 is blocked on most clouds — don't use it. The same transport works in Express, Next.js, and NestJS.
Install Nodemailer
Add it to your Node.js project (Node 18+). The package is actively maintained.
Shellnpm install nodemailerCreate a transport
Point
createTransportatsmtp.unitpost.com. Use port 587 withsecure: falsefor STARTTLS, or port 465 withsecure: truefor implicit TLS. The username is alwaysunitpost; the password is your API key withemails:send.JavaScriptimport nodemailer from "nodemailer"; const transporter = nodemailer.createTransport({ host: "smtp.unitpost.com", port: 587, secure: false, requireTLS: true, auth: { user: "unitpost", pass: process.env.UNITPOST_API_KEY, }, });Port 25 vs 587: 25 is the legacy submission port and is blocked by AWS, GCP, and most VPS providers. 587 with STARTTLS is what you want. 465 is implicit TLS if 587 is filtered.
Send an email
The
fromaddress must be on a domain you've verified in Unitpost. This is the samesendMailcall in a Next.js Route Handler or a NestJS provider.JavaScriptawait transporter.sendMail({ from: "you@yourdomain.com", to: "customer@example.com", subject: "Hello from Unitpost", html: "<h1>Welcome!</h1><p>Sent via SMTP.</p>", });
Supabase
Point Supabase's custom SMTP at Unitpost so auth emails send from your own verified domain — and skip Supabase's built-in auth-email rate limits.
Open Supabase SMTP settings
In the Supabase dashboard go to Project Settings → Authentication → SMTP Settings and enable Custom SMTP.
Enter your Unitpost credentials
Host smtp.unitpost.com Port 587 Username unitpost Password Your Unitpost API key Sender email auth@yourdomain.com (verified) Sender name Your app name The sender email must be on a domain you've verified in Unitpost, or sends are rejected with a 550.
Save and send a test
Save the settings, then trigger a magic link or signup confirmation. Supabase renders its own auth templates; Unitpost just delivers them.
Confirm delivery
The auth email shows up in your Unitpost Emails view with full tracking.
Because delivery now runs through Unitpost, your plan's sending limits apply instead of Supabase's default auth-email throttle.
WordPress
WordPress sends mail via PHP's `mail()` by default, which most hosts deliver poorly. Route it through Unitpost SMTP with a plugin like WP Mail SMTP.
Install an SMTP plugin
From Plugins → Add New, install and activate WP Mail SMTP (or a comparable SMTP plugin).
Choose the "Other SMTP" mailer
In the plugin settings, pick the generic Other SMTP option (not a named provider).
Enter your Unitpost SMTP settings
SMTP Host smtp.unitpost.com Encryption TLS (STARTTLS) SMTP Port 587 Authentication On SMTP Username unitpost SMTP Password Your Unitpost API key From Email you@yourdomain.com (verified) Store the API key in the plugin's password field. Set the From Email to an address on your verified domain.
Send a test email
Use the plugin's Email Test tab to send yourself a message, then confirm it in your Unitpost Emails view.
Auth0
Configure a custom SMTP email provider in Auth0 so your tenant's emails deliver from your verified domain through Unitpost.
Open the email provider settings
In the Auth0 dashboard go to Branding → Email Provider (or Emails → Provider on older tenants) and choose SMTP.
Enter your Unitpost credentials
From you@yourdomain.com (verified) Host smtp.unitpost.com Port 587 Username unitpost Password Your Unitpost API key Save and send a test
Save the provider, then use Auth0's Send Test Email button to verify the connection.
Enable the emails you want
Under Branding → Email Templates, toggle on verification, welcome, password-reset, and other templates. Auth0 renders them; Unitpost delivers.
Gmail
Add an address on your domain to Gmail's Send mail as, so mail you write in Gmail goes out through Unitpost from your verified domain.
Check the address can receive mail
The address must be on a domain you've verified in Unitpost. Gmail confirms it by emailing a code to that address, so it also needs an inbox or forwarding that you can read.
Open Send mail as
In Gmail go to Settings → See all settings → Accounts and Import. Under Send mail as, click Add another email address, enter your name and the address, then click Next Step.
Enter your Unitpost SMTP settings
SMTP Server smtp.unitpost.com Port 587 Username unitpost Password Your Unitpost API key Security Secured connection using TLS Use port 465 with Secured connection using SSL if you prefer implicit TLS. The username is always unitpost, not your email address.
Confirm the address
Click Add Account. Gmail checks the connection, then emails a confirmation code to the address. Enter the code to finish.
Send and verify
Compose a message, pick the address in From, and send. It shows up in your Unitpost Emails view.
Mail sent this way counts toward your plan like any other send. On the Free plan each message carries the small “Sent with Unitpost” mark.
Rails
Set Action Mailer's SMTP settings to route your Rails app's mail through Unitpost. Same job as Nodemailer — different stack.
Configure Action Mailer
In your environment config (e.g.
config/environments/production.rb), set the delivery method and SMTP settings.Rubyconfig.action_mailer.delivery_method = :smtp config.action_mailer.smtp_settings = { address: "smtp.unitpost.com", port: 587, user_name: "unitpost", password: ENV["UNITPOST_API_KEY"], authentication: :plain, enable_starttls_auto: true, }Set your sender
Use a
fromaddress on a verified domain in your mailer.Rubyclass UserMailer < ApplicationMailer default from: "you@yourdomain.com" def welcome_email mail(to: "customer@example.com", subject: "Welcome!") end endDeliver and verify
Trigger the mailer (
UserMailer.welcome_email.deliver_now) and confirm the send in your Unitpost Emails view.
Laravel
Laravel reads SMTP settings from your `.env`. Point the mailer at Unitpost and send from a verified domain.
Set your mail environment variables
Add the following to your
.envfile.ShellMAIL_MAILER=smtp MAIL_HOST=smtp.unitpost.com MAIL_PORT=587 MAIL_USERNAME=unitpost MAIL_PASSWORD=${UNITPOST_API_KEY} MAIL_ENCRYPTION=tls MAIL_FROM_ADDRESS=you@yourdomain.com MAIL_FROM_NAME="${APP_NAME}"MAIL_FROM_ADDRESS must be on a domain you've verified in Unitpost.
Clear the config cache
If you cache config in production, refresh it so the new values load.
Shellphp artisan config:clearSend and verify
Send a mailable (e.g.
Mail::to($user)->send(new WelcomeMail())) and confirm it in your Unitpost Emails view.
Django
Configure Django's built-in SMTP email backend to send through Unitpost. This is the same job as Nodemailer — Python instead of Node.
Configure your settings
Add the SMTP settings to
settings.py. Keep the API key in an environment variable.PythonEMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend" EMAIL_HOST = "smtp.unitpost.com" EMAIL_PORT = 587 EMAIL_USE_TLS = True EMAIL_HOST_USER = "unitpost" EMAIL_HOST_PASSWORD = os.environ["UNITPOST_API_KEY"] DEFAULT_FROM_EMAIL = "you@yourdomain.com"Send an email
Use
send_mailor anEmailMessage. The from address must be on a verified domain.Pythonfrom django.core.mail import send_mail send_mail( subject="Hello from Unitpost", message="Sent via SMTP.", from_email="you@yourdomain.com", recipient_list=["customer@example.com"], html_message="<h1>Welcome!</h1>", )Verify delivery
Check your Unitpost Emails view for the message and its status.
PHPMailer
Use PHPMailer's SMTP mode to deliver through Unitpost from plain PHP. Port 587 with STARTTLS; don't use port 25.
Install PHPMailer
Add it via Composer.
Shellcomposer require phpmailer/phpmailerConfigure and send
Set PHPMailer to SMTP mode with your Unitpost credentials.
PHP<?php use PHPMailer\PHPMailer\PHPMailer; $mail = new PHPMailer(true); $mail->isSMTP(); $mail->Host = "smtp.unitpost.com"; $mail->SMTPAuth = true; $mail->Username = "unitpost"; $mail->Password = getenv("UNITPOST_API_KEY"); $mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS; $mail->Port = 587; $mail->setFrom("you@yourdomain.com", "Your App"); $mail->addAddress("customer@example.com"); $mail->isHTML(true); $mail->Subject = "Hello from Unitpost"; $mail->Body = "<h1>Welcome!</h1><p>Sent via SMTP.</p>"; $mail->send();Verify delivery
The message appears in your Unitpost Emails view with full tracking.
Next.js
Send from a Next.js Route Handler with Nodemailer pointed at Unitpost SMTP. Keep the API key on the server — never in a Client Component.
Install Nodemailer
Shellnpm install nodemailer npm install -D @types/nodemailerCreate a Route Handler
Server-only. The
fromaddress must be on a verified domain.TypeScriptimport nodemailer from "nodemailer"; import { NextResponse } from "next/server"; const transporter = nodemailer.createTransport({ host: "smtp.unitpost.com", port: 587, secure: false, requireTLS: true, auth: { user: "unitpost", pass: process.env.UNITPOST_API_KEY, }, }); export async function POST() { await transporter.sendMail({ from: "you@yourdomain.com", to: "customer@example.com", subject: "Hello from Next.js", html: "<p>Sent via SMTP.</p>", }); return NextResponse.json({ ok: true }); }Verify delivery
Check Emails. Same transport as the Nodemailer guide — this page is the Next.js wiring.
NestJS
Inject a Nodemailer transport in NestJS and send over Unitpost SMTP. Same credentials as any other stack.
Install Nodemailer
Shellnpm install nodemailer npm install -D @types/nodemailerProvide a transporter
TypeScriptimport { Injectable } from "@nestjs/common"; import nodemailer from "nodemailer"; @Injectable() export class MailService { private transporter = nodemailer.createTransport({ host: "smtp.unitpost.com", port: 587, secure: false, auth: { user: "unitpost", pass: process.env.UNITPOST_API_KEY, }, }); sendWelcome(to: string) { return this.transporter.sendMail({ from: "you@yourdomain.com", to, subject: "Welcome", html: "<p>Sent via SMTP.</p>", }); } }Verify delivery
The send shows up in Emails. See also Nodemailer.
Express
Send from an Express route with Nodemailer pointed at Unitpost. Keep the key in env, not in the repo.
Install Nodemailer
Shellnpm install nodemailerSend from a route
JavaScriptimport express from "express"; import nodemailer from "nodemailer"; const transporter = nodemailer.createTransport({ host: "smtp.unitpost.com", port: 587, secure: false, requireTLS: true, auth: { user: "unitpost", pass: process.env.UNITPOST_API_KEY, }, }); const app = express(); app.post("/send", async (_req, res) => { await transporter.sendMail({ from: "you@yourdomain.com", to: "customer@example.com", subject: "Hello from Express", html: "<p>Sent via SMTP.</p>", }); res.json({ ok: true }); });Verify delivery
Confirm in Emails.
Python
Python's smtplib talks SMTP directly. Point it at Unitpost on port 587 with STARTTLS. Django and Flask wrap this; this page is the bare client.
Send with smtplib
Pythonimport os import smtplib from email.message import EmailMessage msg = EmailMessage() msg["From"] = "you@yourdomain.com" msg["To"] = "customer@example.com" msg["Subject"] = "Hello from Python" msg.set_content("Sent via SMTP.") msg.add_alternative("<p>Sent via SMTP.</p>", subtype="html") with smtplib.SMTP("smtp.unitpost.com", 587) as smtp: smtp.starttls() smtp.login("unitpost", os.environ["UNITPOST_API_KEY"]) smtp.send_message(msg)
Flask
Configure Flask-Mail's SMTP settings for Unitpost and send from a verified domain.
Install Flask-Mail
Shellpip install Flask-MailConfigure and send
Pythonimport os from flask import Flask from flask_mail import Mail, Message app = Flask(__name__) app.config.update( MAIL_SERVER="smtp.unitpost.com", MAIL_PORT=587, MAIL_USE_TLS=True, MAIL_USERNAME="unitpost", MAIL_PASSWORD=os.environ["UNITPOST_API_KEY"], MAIL_DEFAULT_SENDER="you@yourdomain.com", ) mail = Mail(app) def send_welcome(to: str) -> None: msg = Message("Welcome", recipients=[to], html="<p>Sent via SMTP.</p>") mail.send(msg)Verify delivery
Check Emails. Bare Python: smtplib.
FastAPI
Call Python's SMTP client from a FastAPI route. Same host, username, and API-key password as every other stack.
Send from a route
Pythonimport os import smtplib from email.message import EmailMessage from fastapi import FastAPI app = FastAPI() @app.post("/send") def send() -> dict[str, bool]: msg = EmailMessage() msg["From"] = "you@yourdomain.com" msg["To"] = "customer@example.com" msg["Subject"] = "Hello from FastAPI" msg.set_content("Sent via SMTP.") with smtplib.SMTP("smtp.unitpost.com", 587) as smtp: smtp.starttls() smtp.login("unitpost", os.environ["UNITPOST_API_KEY"]) smtp.send_message(msg) return {"ok": True}Verify delivery
Confirm in Emails.
Go
Go's net/smtp client can STARTTLS to Unitpost on port 587. Username is the literal `unitpost`; password is an API key.
Send with net/smtp
Gopackage main import ( "crypto/tls" "net/smtp" "os" ) func main() { host := "smtp.unitpost.com" auth := smtp.PlainAuth("", "unitpost", os.Getenv("UNITPOST_API_KEY"), host) to := []string{"customer@example.com"} msg := []byte("From: you@yourdomain.com\r\n" + "To: customer@example.com\r\n" + "Subject: Hello from Go\r\n" + "\r\n" + "Sent via SMTP.\r\n") c, err := smtp.Dial(host + ":587") if err != nil { panic(err) } defer c.Close() if err = c.StartTLS(&tls.Config{ServerName: host}); err != nil { panic(err) } if err = c.Auth(auth); err != nil { panic(err) } if err = c.Mail("you@yourdomain.com"); err != nil { panic(err) } if err = c.Rcpt(to[0]); err != nil { panic(err) } w, err := c.Data() if err != nil { panic(err) } if _, err = w.Write(msg); err != nil { panic(err) } if err = w.Close(); err != nil { panic(err) } _ = c.Quit() }Port 587 needs an explicit STARTTLS before AUTH (PLAIN and LOGIN are both accepted). From must be on a verified domain.
Verify delivery
The message appears in Emails.
Spring Boot
Set Spring Mail properties to Unitpost SMTP and send with JavaMailSender. Port 587, STARTTLS, username `unitpost`.
Set mail properties
Propertiesspring.mail.host=smtp.unitpost.com spring.mail.port=587 spring.mail.username=unitpost spring.mail.password=${UNITPOST_API_KEY} spring.mail.properties.mail.smtp.auth=true spring.mail.properties.mail.smtp.starttls.enable=trueSend with JavaMailSender
JavaMimeMessage message = mailSender.createMimeMessage(); MimeMessageHelper helper = new MimeMessageHelper(message, true); helper.setFrom("you@yourdomain.com"); helper.setTo("customer@example.com"); helper.setSubject("Hello from Spring"); helper.setText("<p>Sent via SMTP.</p>", true); mailSender.send(message);Verify delivery
Check Emails.
.NET
System.Net.Mail.SmtpClient is obsolete. Use MailKit, STARTTLS on 587, username `unitpost`, API key as password.
Add MailKit
Shelldotnet add package MailKitSend
C#using MailKit.Net.Smtp; using MailKit.Security; using MimeKit; var message = new MimeMessage(); message.From.Add(MailboxAddress.Parse("you@yourdomain.com")); message.To.Add(MailboxAddress.Parse("customer@example.com")); message.Subject = "Hello from .NET"; message.Body = new TextPart("html") { Text = "<p>Sent via SMTP.</p>" }; using var client = new SmtpClient(); await client.ConnectAsync("smtp.unitpost.com", 587, SecureSocketOptions.StartTls); await client.AuthenticateAsync("unitpost", Environment.GetEnvironmentVariable("UNITPOST_API_KEY")); await client.SendAsync(message); await client.DisconnectAsync(true);Verify delivery
Confirm in Emails.
Sentry
Self-hosted Sentry emails issue alerts, weekly reports and the links that verify a user's email address. Outbound mail comes from the `mail.*` keys in `sentry/config.yml`, which point at the bundled `smtp` relay container until you change `mail.host`. The catch: `sentry/sentry.conf.py` builds `mail.from` from `SENTRY_MAIL_HOST`, and that wins over anything you put in `config.yml`.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key. Copy it now; it's shown once. Mail goes out as
sentry@plus the domain inSENTRY_MAIL_HOST, so that domain must be verified.Set the From domain in .env
sentry/sentry.conf.pysetsmail.fromtosentry@plusSENTRY_MAIL_HOST. Set that variable in the.envat the root of your self-hosted checkout to your verified domain.EnvSENTRY_MAIL_HOST=yourdomain.comWant another address, such as
alerts@yourdomain.com? Delete themail.list-namespaceandmail.fromlines under# Mail #insentry/sentry.conf.py, then setmail.frominconfig.yml.Point mail.* at Unitpost
In
sentry/config.yml, replacemail.host: 'smtp'(the bundled relay) and uncomment the connection keys.mail.use-tlsis STARTTLS on port 587 andmail.use-sslis implicit TLS on 465. The file warns they must not appear together, so uncomment only one.YAMLmail.backend: 'smtp' mail.host: 'smtp.unitpost.com' mail.port: 587 mail.username: 'unitpost' mail.password: 'pk_live_...' mail.use-tls: trueFor port 465, set
mail.port: 465andmail.use-ssl: true, and leavemail.use-tlscommented out.Rebuild and restart
The containers read
.envandconfig.ymlwhen they start. Re-run the installer from your self-hosted checkout; it rebuilds and restarts them.Shell./install.shSend a test from the admin Mail page
As a superuser, open
/manage/status/mail/on your instance. SMTP Settings lists the host, port, username and STARTTLS or SSL flag that loaded. Under Test Settings, the Send a test email button mails your own account address; find it in Unitpost Emails.If the test fails
535 5.7.8 Username must be 'unitpost'meansmail.usernameholds an email address.550 5.7.1means the From domain isn't verified, so checkSENTRY_MAIL_HOST. A hang on port 465 usually meansmail.use-tlsis set wheremail.use-sslbelongs.
GitLab
Self-managed GitLab (Linux package) sends notifications, password resets and confirmations with the `gitlab_rails['smtp_*']` keys in `/etc/gitlab/gitlab.rb`. The common mistake is turning on both TLS flags: `smtp_enable_starttls_auto` is for 587, `smtp_tls` is for 465, and setting both to `true` fails with `:enable_starttls and :tls are mutually exclusive`.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key. GitLab sends as
gitlab_email_from, so pick that address on a verified domain.Add the SMTP block to gitlab.rb
Edit
/etc/gitlab/gitlab.rbon the GitLab server. For port 587, keepsmtp_enable_starttls_autoon andsmtp_tlsoff.Rubygitlab_rails['smtp_enable'] = true gitlab_rails['smtp_address'] = "smtp.unitpost.com" gitlab_rails['smtp_port'] = 587 gitlab_rails['smtp_user_name'] = "unitpost" gitlab_rails['smtp_password'] = "pk_live_..." gitlab_rails['smtp_domain'] = "yourdomain.com" gitlab_rails['smtp_authentication'] = "login" gitlab_rails['smtp_enable_starttls_auto'] = true gitlab_rails['smtp_tls'] = false gitlab_rails['smtp_openssl_verify_mode'] = 'peer' gitlab_rails['gitlab_email_from'] = 'gitlab@yourdomain.com' gitlab_rails['gitlab_email_reply_to'] = 'noreply@yourdomain.com'For port 465, set
smtp_portto465,smtp_tlstotrueandsmtp_enable_starttls_autotofalse.Reconfigure GitLab
Changes in
gitlab.rbapply only after a reconfigure.Shellsudo gitlab-ctl reconfigureSend a test from the Rails console
Open the console with
sudo gitlab-rails console, then send a message withNotify.test_email. A failure prints the SMTP error right there; a success shows up in Unitpost Emails.RubyNotify.test_email('you@example.com', 'Unitpost SMTP test', 'Sent from GitLab').deliver_nowIf it fails
In the same console,
ActionMailer::Base.smtp_settingsshows what GitLab loaded.535 5.7.8meanssmtp_user_nameisn'tunitpost.550 5.7.1meansgitlab_email_fromisn't on a verified domain. Themutually exclusiveerror means both TLS flags aretrue.
Ghost
Self-hosted Ghost sends staff invitations, password resets, member signups and member login links through the `mail` block in `config.production.json`. Newsletters are a separate path: Ghost delivers them only through Mailgun's bulk API and can't use SMTP, so this setup covers everything except newsletter sends.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key. Ghost sends from
mail.from, so use an address on a verified domain.Add the SMTP transport
In
config.production.jsonin your Ghost install directory, add amailblock. Ghost handsoptionsto Nodemailer, sosecure: falseon port 587 upgrades with STARTTLS, andsecure: truebelongs with 465.JSON"mail": { "transport": "SMTP", "from": "Your Site <noreply@yourdomain.com>", "options": { "host": "smtp.unitpost.com", "port": 587, "secure": false, "auth": { "user": "unitpost", "pass": "pk_live_..." } } }Running Ghost in Docker? Every config key has an environment variable form with double underscores, such as
mail__transport=SMTP,mail__options__host=smtp.unitpost.comandmail__options__auth__pass.Restart Ghost
From the install directory, restart with Ghost-CLI so the new config loads. In Docker, recreate the container instead.
Shellghost restartSend a test
Invite a staff user from Ghost Admin, or request a password reset from the
/ghostsign-in page. The email shows up in Unitpost Emails.Newsletters stay on a bulk API
Ghost's FAQ says newsletter delivery requires a bulk mail API and can't use SMTP, so the transport above never carries newsletters. Ghost doesn't require its built-in newsletter feature, though: you can export members and send newsletters as Unitpost campaigns instead.
Keycloak
Keycloak sends verify-email, password-reset and other login-flow emails with the SMTP settings on each realm's **Email** tab. Every realm has its own settings, so filling them in on `master` does nothing for your app's realm. **Test connection** mails the signed-in admin, and asks you to add an email address to that admin first if it has none.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key. Keycloak's From field needs an address on a verified domain.
Open the realm's Email tab
In the admin console, switch to the realm your app signs in to, click Realm settings, then the Email tab.
Enter the connection
From no-reply@yourdomain.com From display name Your app Host smtp.unitpost.com Port 587 Encryption Enable StartTLS Authentication On Username unitpost Authentication Type Password Password Your Unitpost API key For port 465, tick Enable SSL instead of Enable StartTLS. With neither ticked, Keycloak tries to log in before TLS and Unitpost answers
538.Save and test the connection
Click Save, then Test connection. Keycloak sends a message to the email address of the admin you're signed in as and reports success or the SMTP error. Realm settings apply on save, with nothing to restart.
If the test fails
535 5.7.8means Username isn'tunitpost.550 5.7.1means From isn't on a verified domain. A timeout on 465 means Enable StartTLS is ticked where Enable SSL belongs.
Strapi
Strapi's Email feature uses `sendmail` until you install a provider; for SMTP that's `@strapi/provider-email-nodemailer`, configured in `config/plugins.js` or `config/plugins.ts`. The Users & Permissions plugin needs its own fix: its account confirmation and reset password templates carry a **Shipper email** that defaults to `no-reply@strapi.io`, and Unitpost rejects that sender.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key. Both
defaultFromand the Users & Permissions Shipper email need to be on a verified domain.Install the Nodemailer provider
Shellnpm install @strapi/provider-email-nodemailer --saveConfigure the email plugin
providerOptionsgo to Nodemailer as they are:secure: falseon port 587 upgrades with STARTTLS, andrequireTLS: truerefuses to continue without it. For port 465, setsecure: true. Keep the key in.envasSMTP_PASSWORD.JavaScript// config/plugins.js module.exports = ({ env }) => ({ email: { config: { provider: "nodemailer", providerOptions: { host: env("SMTP_HOST", "smtp.unitpost.com"), port: env.int("SMTP_PORT", 587), secure: false, requireTLS: true, auth: { user: env("SMTP_USERNAME", "unitpost"), pass: env("SMTP_PASSWORD"), }, }, settings: { defaultFrom: "no-reply@yourdomain.com", defaultReplyTo: "support@yourdomain.com", }, }, }, });Restart and fix the shipper email
Restart Strapi so it loads the provider. Then open Settings → Users & Permissions Plugin → Email templates, edit each template, and set Shipper email to an address on your verified domain.
Send a test email
Under Settings → Email plugin → Configuration, type a Recipient email under Test email delivery and click Send test email. Recent versions also have Test connection, which checks the SMTP login without sending.
n8n
Self-hosted n8n emails user invites, password resets and sharing notifications using the `N8N_SMTP_*` environment variables. Two defaults trip people up: `N8N_SMTP_PORT` is 465 and `N8N_SMTP_SSL` is `true`, so a 587 setup needs `N8N_SMTP_SSL=false`. These variables don't touch the Send Email node, which has its own SMTP credential.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key. Set
N8N_SMTP_SENDERto an address on a verified domain: n8n only falls back toN8N_SMTP_USERas the sender when it contains an @, andunitpostdoesn't.Set the environment variables
EnvN8N_EMAIL_MODE=smtp N8N_SMTP_HOST=smtp.unitpost.com N8N_SMTP_PORT=587 N8N_SMTP_USER=unitpost N8N_SMTP_PASS=pk_live_... N8N_SMTP_SENDER=n8n@yourdomain.com N8N_SMTP_SSL=false N8N_SMTP_STARTTLS=trueFor port 465, set
N8N_SMTP_PORT=465andN8N_SMTP_SSL=true.N8N_SMTP_STARTTLSonly applies while SSL is off.Restart n8n
A running n8n instance doesn't pick up new SMTP variables. Restart the process or recreate the container.
Test with an invite
There's no test button for instance email. Open Settings → Users, click Invite, and invite an address you can read. The send also appears in Unitpost Emails.
Use the same values in the Send Email node
Workflows send through the Send Email node's SMTP credential, not the variables above.
User unitpost Password Your Unitpost API key Host smtp.unitpost.com Port 587 SSL/TLS Off (on for port 465)
Grafana
Grafana sends alert notifications, user invites and password resets with the `[smtp]` section of `grafana.ini` (`/etc/grafana/grafana.ini` on deb and RPM installs). `host` takes host and port in one value, and Grafana switches to implicit TLS only when that port is exactly 465. Unitpost's 2465 fallback therefore won't work here; if 587 is blocked, use 2587.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key.
from_addressdefaults toadmin@grafana.localhost, so change it to an address on a verified domain.Edit grafana.ini
Left empty,
startTLS_policyupgrades only if the server offers it;MandatoryStartTLSrefuses to send without TLS. For implicit TLS, usehost = smtp.unitpost.com:465and leave the policy empty.ini[smtp] enabled = true host = smtp.unitpost.com:587 user = unitpost password = pk_live_... from_address = grafana@yourdomain.com from_name = Grafana startTLS_policy = MandatoryStartTLSIn Docker, each key maps to
GF_SMTP_<KEY>:GF_SMTP_ENABLED=true,GF_SMTP_HOST=smtp.unitpost.com:587,GF_SMTP_USER=unitpost,GF_SMTP_PASSWORD,GF_SMTP_FROM_ADDRESSandGF_SMTP_STARTTLS_POLICY.Restart Grafana
Grafana reads
grafana.iniat startup.Shellsudo systemctl restart grafana-serverTest an email contact point
Go to Alerts & IRM → Alerting → Notification configuration and open the Contact points tab. Edit or create a contact point with the Email integration, click Test, then Send test notification.
If the test fails
SMTP not configured, check your grafana.ini config file's [smtp] sectionmeansenabledis stillfalseor Grafana hasn't restarted. A timeout on 2465 is the port 465 rule above.550 5.7.1meansfrom_addressisn't on a verified domain.
Discourse
Discourse uses outgoing mail to validate new accounts and to send notifications and digests. A standard install reads `DISCOURSE_SMTP_*` from `/var/discourse/containers/app.yml`, and the port defaults to 25 unless you set it. The From address defaults to `noreply@` plus your forum's hostname, so either verify that hostname or set `DISCOURSE_NOTIFICATION_EMAIL`.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key, then verify the domain your notification address uses.
Edit containers/app.yml
Under
env:, set the SMTP keys. Discourse uses STARTTLS by default, so port 587 needs nothing more. For port 465, setDISCOURSE_SMTP_PORT: 465andDISCOURSE_SMTP_FORCE_TLS: true; Discourse turns STARTTLS off by itself when implicit TLS is forced.YAMLenv: # ...your existing keys DISCOURSE_SMTP_ADDRESS: smtp.unitpost.com DISCOURSE_SMTP_PORT: 587 DISCOURSE_SMTP_USER_NAME: unitpost DISCOURSE_SMTP_PASSWORD: "pk_live_..." DISCOURSE_NOTIFICATION_EMAIL: noreply@yourdomain.comKeep the password in quotes: the sample file warns that a
#in an unquoted value can be misread.Rebuild the container
Changes to
app.ymlonly apply after a rebuild, which takes the forum offline while it runs.Shellcd /var/discourse ./launcher rebuild appSend a test email
In the admin panel, open Emails (
/admin/email), enter your address in the test field and click Send test email. On the server,./discourse-doctorchecks the mail configuration too.If the test fails
A
Net::ReadTimeouton port 465 usually meansDISCOURSE_SMTP_FORCE_TLSis missing.535 5.7.8meansDISCOURSE_SMTP_USER_NAMEisn'tunitpost.550 5.7.1means the From domain isn't verified.
Mastodon
Mastodon sends sign-up confirmations, password resets and notification emails from its Sidekiq workers, using the `SMTP_*` variables in `.env.production`. `SMTP_FROM_ADDRESS` falls back to `notifications@localhost`, which Unitpost rejects, so set it to an address on your verified domain.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key. Verify the domain you'll use in
SMTP_FROM_ADDRESS.Set the SMTP variables
Edit
.env.productionin the Mastodon directory.SMTP_ENABLE_STARTTLS=alwaysrequires the upgrade on 587; the defaultautoonly tries it when offered.EnvSMTP_SERVER=smtp.unitpost.com SMTP_PORT=587 SMTP_LOGIN=unitpost SMTP_PASSWORD=pk_live_... SMTP_AUTH_METHOD=plain SMTP_ENABLE_STARTTLS=always SMTP_FROM_ADDRESS=notifications@yourdomain.comFor port 465, use
SMTP_PORT=465andSMTP_TLS=true, and removeSMTP_ENABLE_STARTTLS: STARTTLS and implicit TLS can't be on together.Restart Sidekiq and reload the web process
Sidekiq delivers the mail, so it has to restart to load the new values. The web process reloads without downtime.
Shellsudo systemctl restart mastodon-sidekiq sudo systemctl reload mastodon-webSend a test
A running server has no test button. Sign out and use Forgot your password? on the sign-in page with an account whose inbox you can read. On a fresh install,
RAILS_ENV=production bin/rails mastodon:setupoffers to send a test email after its SMTP questions.If nothing arrives
Failed deliveries wait as retries in the Sidekiq dashboard at
/sidekiq, with the SMTP reply.550 5.7.1meansSMTP_FROM_ADDRESSisn't on a verified domain;535 5.7.8meansSMTP_LOGINisn'tunitpost.
Nextcloud
Nextcloud sends password resets, share notifications and activity emails through the **Email server** form under **Administration settings → Basic settings**, which writes `mail_*` keys to `config/config.php`. The From address is split in two: `mail_from_address` holds only the part before the @, and `mail_domain` holds the domain.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key. The domain in
mail_domainmust be verified.Fill in the Email server form
Pick None/STARTTLS for port 587: Nextcloud upgrades with STARTTLS whenever the server offers it, and Unitpost always does on 587. Pick SSL (SSL/TLS in newer releases) for port 465.
Send mode SMTP Encryption None/STARTTLS From address nextcloud @ yourdomain.com Server address smtp.unitpost.com : 587 Authentication Required Login unitpost Password Your Unitpost API key Or set it in config.php
The same settings as
config/config.phpkeys.mail_smtpsecureis''for STARTTLS on 587 or'ssl'for 465.PHP'mail_smtpmode' => 'smtp', 'mail_smtphost' => 'smtp.unitpost.com', 'mail_smtpport' => 587, 'mail_smtpsecure' => '', 'mail_smtpauth' => true, 'mail_smtpname' => 'unitpost', 'mail_smtppassword' => 'pk_live_...', 'mail_from_address' => 'nextcloud', 'mail_domain' => 'yourdomain.com',Send a test email
Add an email address to your own account under Personal info first: the test button under the form (Send email, or Send test email in newer releases) sends to it. The message then shows in Unitpost Emails.
If the test fails
535 5.7.8means the login isn'tunitpost.550 5.7.1meansmail_domainisn't verified. A hang on port 465 means encryption is still set to None/STARTTLS.
Directus
Directus sends user invites, password resets and the emails your Flows send with the `EMAIL_*` environment variables. `EMAIL_TRANSPORT` defaults to `sendmail` and `EMAIL_FROM` to `no-reply@example.com`, so both need changing. `EMAIL_SMTP_SECURE` goes to Nodemailer as `secure`, which means TLS from the first byte on port 465; on 587 leave it `false`.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key. Set
EMAIL_FROMto an address on a verified domain.Set the environment variables
EnvEMAIL_TRANSPORT=smtp EMAIL_FROM=no-reply@yourdomain.com EMAIL_SMTP_HOST=smtp.unitpost.com EMAIL_SMTP_PORT=587 EMAIL_SMTP_USER=unitpost EMAIL_SMTP_PASSWORD=pk_live_... EMAIL_SMTP_SECURE=falseFor port 465, set
EMAIL_SMTP_PORT=465andEMAIL_SMTP_SECURE=true. Don't setEMAIL_SMTP_IGNORE_TLS=true: it skips STARTTLS, and Unitpost refuses to log in without TLS (538).Restart Directus
Directus reads these variables when it starts, so restart the process or container. With
EMAIL_VERIFY_SETUPat its defaulttrue, a failed SMTP connection is logged asEmail connection failed.Check the connection
Call
/server/healthwith an admin token. For admins, the response includes anemail:connectioncheck that runs a live SMTP verify.Shellcurl -H "Authorization: Bearer $DIRECTUS_ADMIN_TOKEN" https://directus.yourdomain.com/server/healthSend a real one
Use Forgot Password on the sign-in page, or invite a user from the User Directory. The email shows up in Unitpost Emails.
Appwrite
Self-hosted Appwrite sends email verification, magic URL logins, password recovery and team invites with the `_APP_SMTP_*` variables in the `.env` file of your install. `_APP_SMTP_SECURE` must be set: left empty, Appwrite connects without TLS and never tries STARTTLS, and Unitpost refuses to log in on an unencrypted connection.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key.
_APP_SYSTEM_EMAIL_ADDRESSdefaults toteam@appwrite.io; change it to an address on a verified domain.Set the SMTP variables
In Appwrite,
tlsmeans STARTTLS (port 587) andsslmeans implicit TLS (port 465).Env_APP_SMTP_HOST=smtp.unitpost.com _APP_SMTP_PORT=587 _APP_SMTP_SECURE=tls _APP_SMTP_USERNAME=unitpost _APP_SMTP_PASSWORD=pk_live_... _APP_SYSTEM_EMAIL_ADDRESS=no-reply@yourdomain.comFor port 465, use
_APP_SMTP_PORT=465and_APP_SMTP_SECURE=ssl.Apply the changes
Recreate the containers, then confirm the values loaded. If they didn't, run
docker compose up -d --build --force-recreate.Shelldocker compose up -d docker compose exec appwrite varsSend a test
Sign out of the Console and request a password recovery, or invite someone to a team. Follow the mail worker with
docker compose logs -f appwrite-worker(appwrite-worker-mailsif you run workers separately), and look for the send in Unitpost Emails.If it fails
538in the worker log means_APP_SMTP_SECUREis empty, so the login went out before TLS.550 5.7.1means_APP_SYSTEM_EMAIL_ADDRESSis stillteam@appwrite.ioor another unverified domain.
PocketBase
PocketBase sends verification, password reset, email change and OTP emails, and by default hands them to the server's `sendmail` command. Switch it to SMTP under **Settings → Mail settings** in the dashboard; the values are stored with your app's settings, so there's no file to edit. The TLS choice sits under **Show more options**: **Auto (StartTLS)** is for 587 and **Always** is for 465.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key. PocketBase's Sender address must be on a verified domain.
Fill in Mail settings
Turn on Use SMTP mail server, then click Show more options to reach the TLS setting.
Sender name Your app Sender address no-reply@yourdomain.com SMTP server host smtp.unitpost.com Port 587 Username unitpost Password Your Unitpost API key TLS encryption Auto (StartTLS) AUTH method PLAIN (default) For port 465, set TLS encryption to Always.
Save and send a test
Click Save changes, then Send test email. Pick a template such as Password reset and an auth collection, enter a To email address and click Send. The message shows up in Unitpost Emails.
If the test fails
535 5.7.8means Username isn'tunitpost.550 5.7.1means Sender address isn't on a verified domain. A timeout on 465 means TLS encryption is still Auto (StartTLS).
authentik
The authentik Email stage sends enrollment verification and password recovery links using the global `AUTHENTIK_EMAIL__*` settings, unless a stage has SMTP settings of its own. `AUTHENTIK_EMAIL__USE_TLS` is STARTTLS (port 587) and `AUTHENTIK_EMAIL__USE_SSL` is implicit TLS (port 465); they're mutually exclusive, so set exactly one to `true`.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key.
AUTHENTIK_EMAIL__FROMdefaults toauthentik@localhost; set it to an address on a verified domain.Add the email settings to .env
With Docker Compose, append these to the
.envfile next todocker-compose.yml. On Kubernetes, the same settings go invalues.yaml.EnvAUTHENTIK_EMAIL__HOST=smtp.unitpost.com AUTHENTIK_EMAIL__PORT=587 AUTHENTIK_EMAIL__USERNAME=unitpost AUTHENTIK_EMAIL__PASSWORD=pk_live_... AUTHENTIK_EMAIL__USE_TLS=true AUTHENTIK_EMAIL__USE_SSL=false AUTHENTIK_EMAIL__FROM=authentik@yourdomain.comFor port 465, set
AUTHENTIK_EMAIL__PORT=465,AUTHENTIK_EMAIL__USE_SSL=trueandAUTHENTIK_EMAIL__USE_TLS=false.Redeploy
The containers read these settings at startup. With Docker Compose, recreate them; on Kubernetes, run
helm upgradewith your values file.Shelldocker compose up -dSend a test with ak test_email
Run it in the worker container. Add
-Sand a stage name to test with that Email stage's settings. On Kubernetes:kubectl exec -it deployment/authentik-worker -c worker -- ak test_email you@example.com.Shelldocker compose exec worker ak test_email you@example.comCheck your Email stages
Stages set to use the global settings pick up the values above. A stage with its own host, port and credentials needs the same Unitpost values entered on the stage.
Metabase
Self-hosted Metabase emails dashboard subscriptions, alerts and user invites through the SMTP server under **Admin → Settings → Email**. Its **SMTP Security** labels are easy to misread: **SSL** is implicit TLS for port 465, while **TLS** and **STARTTLS** both upgrade a plain connection on 587, and only **STARTTLS** refuses to continue without the upgrade. The sender defaults to `notifications@metabase.com`, so change **From address** before you test.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key. From address must be on a verified domain.
Fill in the email settings
SMTP Host smtp.unitpost.com SMTP Port 587 SMTP Security STARTTLS SMTP Username unitpost SMTP Password Your Unitpost API key From Name Metabase From address metabase@yourdomain.com For port 465, choose SSL. On save, Metabase tests the connection; if it fails, it retries with the other security options and warns you when one of those worked instead.
Or set environment variables
Environment variables take precedence over the admin form. Metabase reads them at startup, so restart it after setting them.
EnvMB_EMAIL_SMTP_HOST=smtp.unitpost.com MB_EMAIL_SMTP_PORT=587 MB_EMAIL_SMTP_SECURITY=starttls MB_EMAIL_SMTP_USERNAME=unitpost MB_EMAIL_SMTP_PASSWORD=pk_live_... MB_EMAIL_FROM_ADDRESS=metabase@yourdomain.com MB_EMAIL_FROM_NAME=MetabaseSend a test email
Click Send test email on the email settings page. Metabase sends it to your own account's address with the subject
Metabase Test Email; check it in Unitpost Emails.If it fails
535 5.7.8means the username isn'tunitpost.550 5.7.1means From address isn't on a verified domain, which includes thenotifications@metabase.comdefault.
Gitea
Gitea sends account confirmations, password resets and issue or pull request notifications through the `[mailer]` section of `app.ini`. Set `PROTOCOL` yourself: left empty, Gitea guesses from the port and treats anything other than 25, 465 or 587 (such as 2587) as `smtps`. Set `FROM` too: it defaults to `USER`, and with `USER = unitpost` Gitea refuses to start with `Invalid mailer.FROM (unitpost)`.
Create a send-only key
In Unitpost, open Settings → SMTP and create a send-only key.
FROMmust be an address on a verified domain.Edit app.ini
Gitea only sends credentials over TLS, so use
smtp+starttlson 587 orsmtpson 465.ini[mailer] ENABLED = true PROTOCOL = smtp+starttls SMTP_ADDR = smtp.unitpost.com SMTP_PORT = 587 USER = unitpost PASSWD = pk_live_... FROM = gitea@yourdomain.comFor port 465, set
PROTOCOL = smtpsandSMTP_PORT = 465. Gitea's docs recommend implicit TLS where the server supports it.Restart Gitea
Gitea reads
app.iniat startup, so restart the service or container after editing it.Send a testing email
Sign in as an admin and open Site Administration → Configuration → Summary. Under Mailer Configuration, enter your address next to Send Testing Email and click Send.
If it fails
unable to infer unspecified mailer.PROTOCOLin the log meansPROTOCOLis empty on a nonstandard port.535 5.7.8meansUSERisn'tunitpost.550 5.7.1meansFROMisn't on a verified domain.