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.

Hostsmtp.unitpost.com
Usernameunitpost(always this literal value)
PasswordYour Unitpost API key(must carry emails:send)
Port (STARTTLS)587(or 2587 if blocked, or 25)
Port (implicit TLS)465(or 2465 if blocked)
SecurityTLS 1.2 or 1.3(required before AUTH)
From addressAny 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Install Nodemailer

    Add it to your Node.js project (Node 18+). The package is actively maintained.

    Shell
    npm install nodemailer
  2. Create a transport

    Point createTransport at smtp.unitpost.com. Use port 587 with secure: false for STARTTLS, or port 465 with secure: true for implicit TLS. The username is always unitpost; the password is your API key with emails:send.

    JavaScript
    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,
      },
    });

    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.

  3. Send an email

    The from address must be on a domain you've verified in Unitpost. This is the same sendMail call in a Next.js Route Handler or a NestJS provider.

    JavaScript
    await transporter.sendMail({
      from: "you@yourdomain.com",
      to: "customer@example.com",
      subject: "Hello from Unitpost",
      html: "<h1>Welcome!</h1><p>Sent via SMTP.</p>",
    });
  4. Verify it in the dashboard

    Open Emails in your Unitpost dashboard — the message appears alongside API sends, with delivery, open, and click status. Framework-specific walkthroughs: Next.js, NestJS, Express.

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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Open Supabase SMTP settings

    In the Supabase dashboard go to Project Settings → Authentication → SMTP Settings and enable Custom SMTP.

  2. Enter your Unitpost credentials

    Hostsmtp.unitpost.com
    Port587
    Usernameunitpost
    PasswordYour Unitpost API key
    Sender emailauth@yourdomain.com (verified)
    Sender nameYour app name

    The sender email must be on a domain you've verified in Unitpost, or sends are rejected with a 550.

  3. 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.

  4. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Install an SMTP plugin

    From Plugins → Add New, install and activate WP Mail SMTP (or a comparable SMTP plugin).

  2. Choose the "Other SMTP" mailer

    In the plugin settings, pick the generic Other SMTP option (not a named provider).

  3. Enter your Unitpost SMTP settings

    SMTP Hostsmtp.unitpost.com
    EncryptionTLS (STARTTLS)
    SMTP Port587
    AuthenticationOn
    SMTP Usernameunitpost
    SMTP PasswordYour Unitpost API key
    From Emailyou@yourdomain.com (verified)

    Store the API key in the plugin's password field. Set the From Email to an address on your verified domain.

  4. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Open the email provider settings

    In the Auth0 dashboard go to Branding → Email Provider (or Emails → Provider on older tenants) and choose SMTP.

  2. Enter your Unitpost credentials

    Fromyou@yourdomain.com (verified)
    Hostsmtp.unitpost.com
    Port587
    Usernameunitpost
    PasswordYour Unitpost API key
  3. Save and send a test

    Save the provider, then use Auth0's Send Test Email button to verify the connection.

  4. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. 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.

  2. 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.

  3. Enter your Unitpost SMTP settings

    SMTP Serversmtp.unitpost.com
    Port587
    Usernameunitpost
    PasswordYour Unitpost API key
    SecuritySecured 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.

  4. Confirm the address

    Click Add Account. Gmail checks the connection, then emails a confirmation code to the address. Enter the code to finish.

  5. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Configure Action Mailer

    In your environment config (e.g. config/environments/production.rb), set the delivery method and SMTP settings.

    Ruby
    config.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,
    }
  2. Set your sender

    Use a from address on a verified domain in your mailer.

    Ruby
    class UserMailer < ApplicationMailer
      default from: "you@yourdomain.com"
    
      def welcome_email
        mail(to: "customer@example.com", subject: "Welcome!")
      end
    end
  3. Deliver 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Set your mail environment variables

    Add the following to your .env file.

    Shell
    MAIL_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.

  2. Clear the config cache

    If you cache config in production, refresh it so the new values load.

    Shell
    php artisan config:clear
  3. Send 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Configure your settings

    Add the SMTP settings to settings.py. Keep the API key in an environment variable.

    Python
    EMAIL_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"
  2. Send an email

    Use send_mail or an EmailMessage. The from address must be on a verified domain.

    Python
    from 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>",
    )
  3. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Install PHPMailer

    Add it via Composer.

    Shell
    composer require phpmailer/phpmailer
  2. Configure 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();
  3. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Install Nodemailer

    Shell
    npm install nodemailer
    npm install -D @types/nodemailer
  2. Create a Route Handler

    Server-only. The from address must be on a verified domain.

    TypeScript
    import 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 });
    }
  3. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Install Nodemailer

    Shell
    npm install nodemailer
    npm install -D @types/nodemailer
  2. Provide a transporter

    TypeScript
    import { 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>",
        });
      }
    }
  3. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Install Nodemailer

    Shell
    npm install nodemailer
  2. Send from a route

    JavaScript
    import 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 });
    });
  3. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Send with smtplib

    Python
    import 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)
  2. Framework wrappers

    Using a framework? Django, Flask, FastAPI.

Flask

Configure Flask-Mail's SMTP settings for Unitpost and send from a verified domain.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Install Flask-Mail

    Shell
    pip install Flask-Mail
  2. Configure and send

    Python
    import 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)
  3. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Send from a route

    Python
    import 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}
  2. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Send with net/smtp

    Go
    package 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.

  2. 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`.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Set mail properties

    Properties
    spring.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=true
  2. Send with JavaMailSender

    Java
    MimeMessage 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);
  3. Verify delivery

    Check Emails.

.NET

System.Net.Mail.SmtpClient is obsolete. Use MailKit, STARTTLS on 587, username `unitpost`, API key as password.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Add MailKit

    Shell
    dotnet add package MailKit
  2. Send

    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);
  3. 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`.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. 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 in SENTRY_MAIL_HOST, so that domain must be verified.

  2. Set the From domain in .env

    sentry/sentry.conf.py sets mail.from to sentry@ plus SENTRY_MAIL_HOST. Set that variable in the .env at the root of your self-hosted checkout to your verified domain.

    Env
    SENTRY_MAIL_HOST=yourdomain.com

    Want another address, such as alerts@yourdomain.com? Delete the mail.list-namespace and mail.from lines under # Mail # in sentry/sentry.conf.py, then set mail.from in config.yml.

  3. Point mail.* at Unitpost

    In sentry/config.yml, replace mail.host: 'smtp' (the bundled relay) and uncomment the connection keys. mail.use-tls is STARTTLS on port 587 and mail.use-ssl is implicit TLS on 465. The file warns they must not appear together, so uncomment only one.

    YAML
    mail.backend: 'smtp'
    mail.host: 'smtp.unitpost.com'
    mail.port: 587
    mail.username: 'unitpost'
    mail.password: 'pk_live_...'
    mail.use-tls: true

    For port 465, set mail.port: 465 and mail.use-ssl: true, and leave mail.use-tls commented out.

  4. Rebuild and restart

    The containers read .env and config.yml when they start. Re-run the installer from your self-hosted checkout; it rebuilds and restarts them.

    Shell
    ./install.sh
  5. Send 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.

  6. If the test fails

    535 5.7.8 Username must be 'unitpost' means mail.username holds an email address. 550 5.7.1 means the From domain isn't verified, so check SENTRY_MAIL_HOST. A hang on port 465 usually means mail.use-tls is set where mail.use-ssl belongs.

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`.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. 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.

  2. Add the SMTP block to gitlab.rb

    Edit /etc/gitlab/gitlab.rb on the GitLab server. For port 587, keep smtp_enable_starttls_auto on and smtp_tls off.

    Ruby
    gitlab_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_port to 465, smtp_tls to true and smtp_enable_starttls_auto to false.

  3. Reconfigure GitLab

    Changes in gitlab.rb apply only after a reconfigure.

    Shell
    sudo gitlab-ctl reconfigure
  4. Send a test from the Rails console

    Open the console with sudo gitlab-rails console, then send a message with Notify.test_email. A failure prints the SMTP error right there; a success shows up in Unitpost Emails.

    Ruby
    Notify.test_email('you@example.com', 'Unitpost SMTP test', 'Sent from GitLab').deliver_now
  5. If it fails

    In the same console, ActionMailer::Base.smtp_settings shows what GitLab loaded. 535 5.7.8 means smtp_user_name isn't unitpost. 550 5.7.1 means gitlab_email_from isn't on a verified domain. The mutually exclusive error means both TLS flags are true.

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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. 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.

  2. Add the SMTP transport

    In config.production.json in your Ghost install directory, add a mail block. Ghost hands options to Nodemailer, so secure: false on port 587 upgrades with STARTTLS, and secure: true belongs 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.com and mail__options__auth__pass.

  3. Restart Ghost

    From the install directory, restart with Ghost-CLI so the new config loads. In Docker, recreate the container instead.

    Shell
    ghost restart
  4. Send a test

    Invite a staff user from Ghost Admin, or request a password reset from the /ghost sign-in page. The email shows up in Unitpost Emails.

  5. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. 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.

  2. 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.

  3. Enter the connection

    Fromno-reply@yourdomain.com
    From display nameYour app
    Hostsmtp.unitpost.com
    Port587
    EncryptionEnable StartTLS
    AuthenticationOn
    Usernameunitpost
    Authentication TypePassword
    PasswordYour 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.

  4. 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.

  5. If the test fails

    535 5.7.8 means Username isn't unitpost. 550 5.7.1 means 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Create a send-only key

    In Unitpost, open Settings → SMTP and create a send-only key. Both defaultFrom and the Users & Permissions Shipper email need to be on a verified domain.

  2. Install the Nodemailer provider

    Shell
    npm install @strapi/provider-email-nodemailer --save
  3. Configure the email plugin

    providerOptions go to Nodemailer as they are: secure: false on port 587 upgrades with STARTTLS, and requireTLS: true refuses to continue without it. For port 465, set secure: true. Keep the key in .env as SMTP_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",
          },
        },
      },
    });
  4. 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.

  5. 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Create a send-only key

    In Unitpost, open Settings → SMTP and create a send-only key. Set N8N_SMTP_SENDER to an address on a verified domain: n8n only falls back to N8N_SMTP_USER as the sender when it contains an @, and unitpost doesn't.

  2. Set the environment variables

    Env
    N8N_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=true

    For port 465, set N8N_SMTP_PORT=465 and N8N_SMTP_SSL=true. N8N_SMTP_STARTTLS only applies while SSL is off.

  3. Restart n8n

    A running n8n instance doesn't pick up new SMTP variables. Restart the process or recreate the container.

  4. 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.

  5. Use the same values in the Send Email node

    Workflows send through the Send Email node's SMTP credential, not the variables above.

    Userunitpost
    PasswordYour Unitpost API key
    Hostsmtp.unitpost.com
    Port587
    SSL/TLSOff (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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Create a send-only key

    In Unitpost, open Settings → SMTP and create a send-only key. from_address defaults to admin@grafana.localhost, so change it to an address on a verified domain.

  2. Edit grafana.ini

    Left empty, startTLS_policy upgrades only if the server offers it; MandatoryStartTLS refuses to send without TLS. For implicit TLS, use host = smtp.unitpost.com:465 and 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 = MandatoryStartTLS

    In 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_ADDRESS and GF_SMTP_STARTTLS_POLICY.

  3. Restart Grafana

    Grafana reads grafana.ini at startup.

    Shell
    sudo systemctl restart grafana-server
  4. Test 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.

  5. If the test fails

    SMTP not configured, check your grafana.ini config file's [smtp] section means enabled is still false or Grafana hasn't restarted. A timeout on 2465 is the port 465 rule above. 550 5.7.1 means from_address isn'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`.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Create a send-only key

    In Unitpost, open Settings → SMTP and create a send-only key, then verify the domain your notification address uses.

  2. Edit containers/app.yml

    Under env:, set the SMTP keys. Discourse uses STARTTLS by default, so port 587 needs nothing more. For port 465, set DISCOURSE_SMTP_PORT: 465 and DISCOURSE_SMTP_FORCE_TLS: true; Discourse turns STARTTLS off by itself when implicit TLS is forced.

    YAML
    env:
      # ...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.com

    Keep the password in quotes: the sample file warns that a # in an unquoted value can be misread.

  3. Rebuild the container

    Changes to app.yml only apply after a rebuild, which takes the forum offline while it runs.

    Shell
    cd /var/discourse
    ./launcher rebuild app
  4. Send 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-doctor checks the mail configuration too.

  5. If the test fails

    A Net::ReadTimeout on port 465 usually means DISCOURSE_SMTP_FORCE_TLS is missing. 535 5.7.8 means DISCOURSE_SMTP_USER_NAME isn't unitpost. 550 5.7.1 means 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. 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.

  2. Set the SMTP variables

    Edit .env.production in the Mastodon directory. SMTP_ENABLE_STARTTLS=always requires the upgrade on 587; the default auto only tries it when offered.

    Env
    SMTP_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.com

    For port 465, use SMTP_PORT=465 and SMTP_TLS=true, and remove SMTP_ENABLE_STARTTLS: STARTTLS and implicit TLS can't be on together.

  3. 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.

    Shell
    sudo systemctl restart mastodon-sidekiq
    sudo systemctl reload mastodon-web
  4. Send 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:setup offers to send a test email after its SMTP questions.

  5. If nothing arrives

    Failed deliveries wait as retries in the Sidekiq dashboard at /sidekiq, with the SMTP reply. 550 5.7.1 means SMTP_FROM_ADDRESS isn't on a verified domain; 535 5.7.8 means SMTP_LOGIN isn't unitpost.

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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Create a send-only key

    In Unitpost, open Settings → SMTP and create a send-only key. The domain in mail_domain must be verified.

  2. 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 modeSMTP
    EncryptionNone/STARTTLS
    From addressnextcloud @ yourdomain.com
    Server addresssmtp.unitpost.com : 587
    AuthenticationRequired
    Loginunitpost
    PasswordYour Unitpost API key
  3. Or set it in config.php

    The same settings as config/config.php keys. mail_smtpsecure is '' 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',
  4. 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.

  5. If the test fails

    535 5.7.8 means the login isn't unitpost. 550 5.7.1 means mail_domain isn'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`.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Create a send-only key

    In Unitpost, open Settings → SMTP and create a send-only key. Set EMAIL_FROM to an address on a verified domain.

  2. Set the environment variables

    Env
    EMAIL_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=false

    For port 465, set EMAIL_SMTP_PORT=465 and EMAIL_SMTP_SECURE=true. Don't set EMAIL_SMTP_IGNORE_TLS=true: it skips STARTTLS, and Unitpost refuses to log in without TLS (538).

  3. Restart Directus

    Directus reads these variables when it starts, so restart the process or container. With EMAIL_VERIFY_SETUP at its default true, a failed SMTP connection is logged as Email connection failed.

  4. Check the connection

    Call /server/health with an admin token. For admins, the response includes an email:connection check that runs a live SMTP verify.

    Shell
    curl -H "Authorization: Bearer $DIRECTUS_ADMIN_TOKEN" https://directus.yourdomain.com/server/health
  5. Send 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Create a send-only key

    In Unitpost, open Settings → SMTP and create a send-only key. _APP_SYSTEM_EMAIL_ADDRESS defaults to team@appwrite.io; change it to an address on a verified domain.

  2. Set the SMTP variables

    In Appwrite, tls means STARTTLS (port 587) and ssl means 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.com

    For port 465, use _APP_SMTP_PORT=465 and _APP_SMTP_SECURE=ssl.

  3. Apply the changes

    Recreate the containers, then confirm the values loaded. If they didn't, run docker compose up -d --build --force-recreate.

    Shell
    docker compose up -d
    docker compose exec appwrite vars
  4. Send 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-mails if you run workers separately), and look for the send in Unitpost Emails.

  5. If it fails

    538 in the worker log means _APP_SMTP_SECURE is empty, so the login went out before TLS. 550 5.7.1 means _APP_SYSTEM_EMAIL_ADDRESS is still team@appwrite.io or 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. 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.

  2. Fill in Mail settings

    Turn on Use SMTP mail server, then click Show more options to reach the TLS setting.

    Sender nameYour app
    Sender addressno-reply@yourdomain.com
    SMTP server hostsmtp.unitpost.com
    Port587
    Usernameunitpost
    PasswordYour Unitpost API key
    TLS encryptionAuto (StartTLS)
    AUTH methodPLAIN (default)

    For port 465, set TLS encryption to Always.

  3. 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.

  4. If the test fails

    535 5.7.8 means Username isn't unitpost. 550 5.7.1 means 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`.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Create a send-only key

    In Unitpost, open Settings → SMTP and create a send-only key. AUTHENTIK_EMAIL__FROM defaults to authentik@localhost; set it to an address on a verified domain.

  2. Add the email settings to .env

    With Docker Compose, append these to the .env file next to docker-compose.yml. On Kubernetes, the same settings go in values.yaml.

    Env
    AUTHENTIK_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.com

    For port 465, set AUTHENTIK_EMAIL__PORT=465, AUTHENTIK_EMAIL__USE_SSL=true and AUTHENTIK_EMAIL__USE_TLS=false.

  3. Redeploy

    The containers read these settings at startup. With Docker Compose, recreate them; on Kubernetes, run helm upgrade with your values file.

    Shell
    docker compose up -d
  4. Send a test with ak test_email

    Run it in the worker container. Add -S and 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.

    Shell
    docker compose exec worker ak test_email you@example.com
  5. Check 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.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Create a send-only key

    In Unitpost, open Settings → SMTP and create a send-only key. From address must be on a verified domain.

  2. Fill in the email settings

    SMTP Hostsmtp.unitpost.com
    SMTP Port587
    SMTP SecuritySTARTTLS
    SMTP Usernameunitpost
    SMTP PasswordYour Unitpost API key
    From NameMetabase
    From addressmetabase@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.

  3. Or set environment variables

    Environment variables take precedence over the admin form. Metabase reads them at startup, so restart it after setting them.

    Env
    MB_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=Metabase
  4. Send 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.

  5. If it fails

    535 5.7.8 means the username isn't unitpost. 550 5.7.1 means From address isn't on a verified domain, which includes the notifications@metabase.com default.

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)`.

Need an API key?

SMTP password is a Unitpost API key with emails:send. Username is always unitpost.

  • 5,000 emails/month
  • 3 API keys
  • 5 sending domains
Get free SMTP key
  1. Create a send-only key

    In Unitpost, open Settings → SMTP and create a send-only key. FROM must be an address on a verified domain.

  2. Edit app.ini

    Gitea only sends credentials over TLS, so use smtp+starttls on 587 or smtps on 465.

    ini
    [mailer]
    ENABLED = true
    PROTOCOL = smtp+starttls
    SMTP_ADDR = smtp.unitpost.com
    SMTP_PORT = 587
    USER = unitpost
    PASSWD = pk_live_...
    FROM = gitea@yourdomain.com

    For port 465, set PROTOCOL = smtps and SMTP_PORT = 465. Gitea's docs recommend implicit TLS where the server supports it.

  3. Restart Gitea

    Gitea reads app.ini at startup, so restart the service or container after editing it.

  4. 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.

  5. If it fails

    unable to infer unspecified mailer.PROTOCOL in the log means PROTOCOL is empty on a nonstandard port. 535 5.7.8 means USER isn't unitpost. 550 5.7.1 means FROM isn't on a verified domain.

Search docs and guides

Search the docs and product guides.