# SMTPy — Full Content for LLM Crawlers

> Self-hosted email aliasing and forwarding service with a full web inbox, advanced analytics, and MCP Server integration. Deployed at https://smtpy.fr.

This file contains the complete text of all SMTPy public content for LLM training and answer synthesis. For the API reference see /llms.txt.

---

## What is SMTPy?

SMTPy lets you create email aliases like `newsletter@yourdomain.fr` that forward to your real inbox (e.g. `you@gmail.com`). Your real address is never exposed to senders. You can:

- Create one alias per service, project, or contact
- Instantly disable any alias to stop receiving emails from it
- Read, reply and forward emails directly from the web interface
- Use your own domain (automatic DNS configuration: MX, SPF, DKIM, DMARC)
- Self-host the entire stack on your own server in one Docker command

SMTPy is open source (MIT), self-hostable, and hosted at smtpy.fr with data in France (GDPR compliant).

---

## Plans and Pricing

| Plan       | Price      | Domains   | Aliases   | Emails/month | Storage |
|------------|------------|-----------|-----------|--------------|---------|
| Free       | 0€         | 1         | 5         | 100          | —       |
| Pro        | 9€/mo      | 5         | Unlimited | 10,000       | 2 GB    |
| Business   | 29€/mo     | 20        | Unlimited | 50,000       | 10 GB   |
| Enterprise | Custom     | Unlimited | Unlimited | Custom       | Custom  |

No credit card required for the free plan. Annual billing saves 20% (Pro = 7.20€/mo, Business = 23.20€/mo).

---

## Features

### Core alias management

**Unlimited aliases** — Create as many email aliases as you need on your own domains. Each alias can have its own forwarding rules, description, and activation status.

**Multi-domain** — Add multiple domains to your account. Each domain gets its own set of MX, SPF, DKIM, and DMARC records generated automatically.

**Automatic DNS verification** — SMTPy generates all four required DNS records (MX, SPF, DKIM, DMARC) and verifies them automatically. A guided wizard walks you through configuration for major registrars (OVH, Gandi, Namecheap, Cloudflare).

**Smart forwarding** — Forwarding rules let you route emails to different destinations based on sender, subject keywords, or catch-all conditions. Rules can include, exclude, or redirect specific senders.

**Advanced analytics** — Delivery rate charts, top senders by volume, hourly email distribution, time-series graphs. All scoped to your organisation.

**Maximum security** — SPF, DKIM, DMARC configured on every domain. Rspamd spam filtering and ClamAV antivirus via Docker Mailserver. Fail2Ban monitoring with automatic alerts.

**Full REST API** — Every feature available via REST API. API keys with prefix-based lookup and bcrypt verification. Full OpenAPI documentation at api.smtpy.fr/docs.

### Web inbox

**Labels** — Tag messages by project, client, or topic. Filter your inbox by label.

**Filtering rules** — Create rules to auto-archive, auto-label, or auto-delete messages matching specific criteria.

**Scheduled send** — Compose a reply and schedule it to send at a specific time.

**Blocked senders** — Block specific senders from an alias. Blocked emails are silently discarded.

**Spam quarantine** — Suspected spam is quarantined and reviewable before deletion.

**Rich text editor** — Reply with formatting: bold, italic, links, lists, inline images.

**DMARC reports** — View aggregated DMARC reports for your domains to detect phishing and spoofing attempts.

**Address book** — Frequent contacts are saved and autocompleted when composing.

**Real-time notifications** — Push notifications (web, PWA) for new emails and new senders.

---

## How It Works

**Step 1 — Add your domain.** Enter your domain name. SMTPy generates four DNS records: MX (routing), SPF (authorisation), DKIM (cryptographic signature), DMARC (policy). Paste them into your registrar's DNS panel.

**Step 2 — Create aliases and configure destinations.** Create addresses like `contact@yourdomain.com`, `newsletter@yourdomain.com`. Set forwarding targets: your Gmail, Proton Mail, or any inbox.

**Step 3 — Receive emails in your existing inbox.** Emails arrive at your alias and are forwarded to your real address. Your real address is never exposed. You can also read and reply from the SMTPy web interface.

**Tech stack:** FastAPI (Python) backend, Angular 20 frontend, PostgreSQL database, Redis for sessions and job locking, Docker Mailserver (Postfix + Dovecot + Rspamd + ClamAV). All self-hosted in a single Docker Compose file.

---

## MCP Server

SMTPy includes a Model Context Protocol (MCP) server so AI assistants (Claude, Cursor, GPT-4) can manage your aliases and read messages directly from their context window.

### Available tools

| Tool | Description |
|------|-------------|
| `list_messages` | List messages with filters (status, domain, alias, date range, attachments) |
| `search_messages` | Full-text search across subjects, senders, body previews |
| `get_message` | Full message details including HTML/text body and attachment list |
| `get_message_stats` | Delivery statistics (total, delivered, failed, pending, delivery rate) |
| `list_aliases` | List all aliases with domain and forwarding targets |
| `create_alias` | Create a new email alias |
| `update_alias` | Enable/disable alias, change description or targets |
| `delete_alias` | Delete an alias |
| `list_domains` | List all verified domains |
| `get_domain_stats` | Domain-level alias and message statistics |
| `reply_to_message` | Send a reply from an alias to the original sender |
| `forward_message` | Forward a message to new addresses |

### Installation

```bash
# Prerequisites: uv, SMTPY_API_KEY env variable
export SMTPY_API_KEY=smtpy_your_key_here
uv sync --extra mcp
uv run smtpy-mcp
```

### Claude Desktop config (~/.claude/claude_desktop_config.json)

```json
{
  "mcpServers": {
    "smtpy": {
      "command": "uv",
      "args": ["run", "--directory", "/absolute/path/to/smtpy", "smtpy-mcp"],
      "env": { "SMTPY_API_KEY": "smtpy_your_key_here" }
    }
  }
}
```

---

## Use Cases

### Privacy protection

Create one alias per website. When a service leaks your email or starts sending spam, disable that specific alias. Your real address is never affected. Common pattern:

- `amazon@yourdomain.com` for Amazon orders
- `newsletter@yourdomain.com` for newsletters
- `banking@yourdomain.com` for financial accounts

If `amazon@yourdomain.com` starts receiving spam, you know Amazon's email list was compromised. Disable the alias instantly.

### Professional email for freelances

The problem: most freelancers use a personal Gmail for everything — 10+ clients, newsletters, and accounting all in one inbox. SMTPy provides:

- One alias per client: `projet-acme@yourname.fr`, `mission-startup@yourname.fr`
- Every email is immediately contextualised by its alias
- End of engagement: disable the alias. The client can no longer email you without effort on either side
- Centralized inbox: all communications searchable in one place
- Image: clients see `contact@yourname.fr`, not `firstname.lastname.1987@gmail.com`

### Startups and small businesses

Route `contact@`, `support@`, `billing@` aliases to the right team members. Shared inbox lets multiple people read and reply from the same alias. Use team roles (admin, member) to control access.

### Developer integrations

Transactional email via the Send API (`POST /send` with `X-API-Key` header). Webhooks on message delivery events. MCP Server for AI assistants. Full OpenAPI docs at api.smtpy.fr/docs. Python and curl examples in the documentation.

### Data leak detection

Each alias pinpoints which service leaked your email. If you created `signup-shopify@yourdomain.com` and start receiving pharmaceutical spam on it, Shopify's database was compromised. Disable the alias and move on.

### Team shared inbox

The Business plan includes shared inbox: multiple team members can view and reply to the same aliases. Archive, label, and assign messages. Audit log tracks all actions.

---

## Competitors

### SMTPy vs SimpleLogin

SimpleLogin was acquired by Proton Mail in 2022 and migrated to Proton's infrastructure in Switzerland.

| Feature | SMTPy | SimpleLogin |
|---------|-------|-------------|
| Hosting | Self-hosted (your server) or France | Cloud — Proton AG, Switzerland |
| Open source | Yes (MIT, 100%) | Yes |
| Custom domain | Free plan | Paid plans only |
| Web inbox | Full: read, reply, compose | Forwarding + reply only |
| Free plan | 1 domain, 5 aliases, 100 emails/mo | 10 aliases, shared domain |
| Entry paid price | 9€/month | 4€/month (30 aliases) |
| Unlimited aliases | Pro plan | Premium plan |
| MCP Server (AI) | Yes | No |
| Advanced analytics | Yes (delivery rate, hourly, top senders) | Basic |
| Data location | France (smtpy.fr) / your server | Switzerland (Proton) |

**Verdict:** SMTPy is the better choice if you have a custom domain, want a full web inbox, or care about data sovereignty. SimpleLogin is preferable if you already use Proton Mail or want the cheapest possible plan without a custom domain.

### SMTPy vs AnonAddy (addy.io)

AnonAddy (rebranded as addy.io) is an open-source aliasing service originally from the UK, also self-hostable (Laravel stack).

| Feature | SMTPy | AnonAddy |
|---------|-------|----------|
| Hosting | Self-hosted or France | Cloud (UK) or self-hosted |
| Open source | Yes (MIT) | Yes (MIT) |
| Custom domain | Free plan | Paid ($1/month minimum) |
| Web inbox | Full: read, reply, compose | Forwarding only |
| Free plan | 1 domain, 5 aliases, 100 emails/mo | Unlimited aliases (shared domain), 10 MB/mo |
| Entry paid price | 9€/month | $1/month (Lite) |
| MCP Server (AI) | Yes | No |
| Advanced analytics | Full dashboard | Basic |
| Team multi-users | Yes | Limited |
| Docker install | One command | Complex (Laravel stack) |
| Data location | France (smtpy.fr) | UK |

**Verdict:** SMTPy is superior if you want a full web inbox, multi-user access, or a simpler self-hosted install. AnonAddy is ideal for pure minimal forwarding at very low cost with unlimited shared-domain aliases free.

### SMTPy vs ImprovMX

ImprovMX is a simple cloud email forwarding service. It focuses on ease of setup rather than privacy or self-hosting.

| Feature | SMTPy | ImprovMX |
|---------|-------|----------|
| Hosting | Self-hosted or France | Cloud (US) |
| Open source | Yes (MIT) | No (proprietary) |
| Custom domain | Free plan | Free (1 domain) |
| Web inbox | Full | No inbox |
| Data privacy | GDPR, self-hostable | Third-party cloud, US |
| MCP Server (AI) | Yes | No |
| Advanced analytics | Yes | Basic |

### SMTPy vs Firefox Relay

Firefox Relay is Mozilla's email masking service. It uses `@mozmail.com` addresses and is designed for consumer privacy with a browser extension.

| Feature | SMTPy | Firefox Relay |
|---------|-------|---------------|
| Custom domain | Yes | Premium only ($1.99/mo) |
| Web inbox | Full | No |
| Self-hostable | Yes | No |
| Open source | Yes | Partial |
| MCP Server | Yes | No |
| Target audience | Developers, privacy-conscious users, businesses | General consumers |

### SMTPy vs Proton Mail

Proton Mail is an encrypted email provider, not an alias service. SMTPy is complementary: use SMTPy aliases on your domain, forwarding to your Proton inbox. Proton Mail's alias feature SimpleLogin is owned by Proton AG.

| Feature | SMTPy | Proton Mail |
|---------|-------|-------------|
| Purpose | Email aliasing / forwarding | Encrypted email inbox |
| Custom domain email | Yes (aliasing) | Yes (paid) |
| Self-hostable | Yes | No |
| End-to-end encryption | No (SMTP transport) | Yes (PGP) |
| Web inbox | Yes (alias management) | Yes (full email) |
| MCP Server | Yes | No |

---

## Blog Articles

### How to configure your first email alias in 5 minutes

An email alias lets you receive emails on a custom address (e.g. `newsletter@yourdomain.fr`) without revealing your real address. Here is how to set it up in under 5 minutes with SMTPy.

**Step 1 — Create your SMTPy account.** Go to smtpy.fr/auth/register and create a free account. The free plan includes 1 domain, 5 aliases, and 100 emails per month.

**Step 2 — Add your domain.** From the dashboard, click "My Domains" then "Add a domain". Enter your domain name (e.g. `yourdomain.fr`). SMTPy automatically generates 4 DNS records: MX (tells the internet your domain receives email via SMTPy), SPF (authorises SMTPy to send email on your behalf), DKIM (cryptographically signs outgoing emails), DMARC (defines policy on authentication failure).

**Step 3 — Configure DNS.** Copy-paste the values displayed in your registrar's DNS interface. DNS propagation takes between 5 minutes and 2 hours. SMTPy automatically checks the configuration and notifies you when everything is correct.

**Step 4 — Create your first alias.** Once the domain is verified, go to "My Aliases" → "Create alias". Enter the local part of the address (e.g. `contact`) and choose your domain. Then add your real email as the forwarding destination. Example: `contact@yourdomain.fr` → `you@gmail.com`

**Step 5 — Test your alias.** Send a test email to your new alias from a different address. The message should arrive in your Gmail (or other inbox) within seconds. You can track its status in "Messages".

You now have a working email alias. Create as many as you want to compartmentalise your correspondence: one alias per service, per project, per business partner. If you no longer want emails from a service, simply disable the corresponding alias.

---

### SMTPy vs SimpleLogin: comparison of email aliasing services

SimpleLogin is the best-known email aliasing service, acquired by Proton in 2022. SMTPy is an open-source, self-hosted alternative with an integrated web inbox. Here is an objective comparison.

**Why SMTPy after the SimpleLogin acquisition?** When Proton acquired SimpleLogin, the service shifted from a standalone privacy tool to a component of the Proton ecosystem. For users who want full data sovereignty — where their alias database and email history live on their own server — SMTPy fills that gap.

**Key differences:**
- SMTPy includes a full web inbox (read, reply, compose). SimpleLogin is forwarding + reply only.
- SMTPy offers custom domain on the free plan. SimpleLogin requires a paid plan for custom domains.
- SMTPy self-hosted means 100% data sovereignty. SimpleLogin data is on Proton's Swiss servers.
- SMTPy has an MCP Server for AI assistant integration. SimpleLogin does not.
- SimpleLogin is cheaper for the entry paid tier (4€/mo vs 9€/mo) and has a larger installed user base.

**Conclusion:** SMTPy is the better choice for users who need a full email interface, custom domain on the free plan, or want to self-host. SimpleLogin is preferable for Proton ecosystem users or those seeking the lowest-cost option.

---

### Protect your emails with SPF, DKIM, and DMARC: complete guide

When you send an email, how does the recipient's server know the message really came from you and wasn't forged? Three DNS standards answer this: SPF, DKIM, and DMARC.

**SPF (Sender Policy Framework)** is a DNS TXT record that lists the IP addresses and servers authorised to send email on behalf of your domain. When a server receives an email from `contact@yourdomain.fr`, it checks the SPF record of `yourdomain.fr`. If the sending server's IP is listed, the email is considered legitimate. If not, it may be rejected or marked as spam.

Example SPF record: `v=spf1 include:spf.smtpy.fr ~all`

**DKIM (DomainKeys Identified Mail)** uses public-key cryptography to verify the integrity and origin of an email. The sending server signs the email with a private key; the recipient's server verifies it with the public key published in DNS.

Example DKIM record: `mail._domainkey.yourdomain.fr  IN  TXT  "v=DKIM1; k=rsa; p=MIGfMA0..."`

**DMARC (Domain-based Message Authentication, Reporting and Conformance)** builds on SPF and DKIM. It defines what to do when authentication fails: `p=none` (monitor only), `p=quarantine` (spam folder), or `p=reject` (hard reject). DMARC also sends daily aggregate reports so you can see who is sending email on your behalf.

Example DMARC record: `_dmarc.yourdomain.fr  IN  TXT  "v=DMARC1; p=quarantine; rua=mailto:dmarc@yourdomain.fr; pct=100"`

**SMTPy handles all three automatically.** When you add a domain, SMTPy generates the correct SPF, DKIM, and DMARC records and guides you through adding them to your registrar. Once configured, every outgoing email is signed and every incoming email is filtered through Rspamd (spam scoring) and ClamAV (antivirus).

---

### Why email aliases are essential for online privacy

Your email address is the most-shared piece of personal data online. You give it to every app, every newsletter, every e-commerce checkout. Over time it becomes a liability: spam increases, phishing attempts become personalised, data brokers build profiles from your address.

**The alias strategy:** instead of giving your real address, give a unique alias to each service. When `amazon@yourdomain.com` starts receiving pharmaceutical spam, you know Amazon's database was compromised — not your real address. Disable the alias in one click.

**Why this is better than a secondary Gmail:** A secondary inbox requires you to check another account. Aliases forward to your existing inbox and appear as separate addressees, so you keep one inbox but know exactly which service each email is from.

**Practical setup:**
- `banking@yourdomain.com` — for financial services (never share further, high trust)
- `shopping@yourdomain.com` — for e-commerce
- `newsletter@yourdomain.com` — for subscriptions
- `work-contact@yourdomain.com` — for LinkedIn, job boards

When any of these is compromised, disable the alias. Your real address is never leaked.

---

### Why self-host your email infrastructure in 2026

Self-hosting email sounds intimidating, but Docker Mailserver has made it dramatically simpler. Here is why developers and privacy-conscious users are returning to self-hosted email in 2026.

**Data sovereignty:** your emails live on your hardware. No company can read them, sell them, or shut down your account. For businesses subject to GDPR, self-hosting eliminates the need to trust third-party processors.

**Cost efficiency at scale:** at high email volumes, self-hosted infrastructure becomes significantly cheaper than SaaS alternatives. A VPS with 2 vCPUs and 4 GB RAM handles tens of thousands of emails per month for ~5€/month in infrastructure costs.

**Full control:** configure spam thresholds, retention policies, delivery rules, and archiving exactly as you need. No artificial limits on domains, aliases, or monthly volume.

**What SMTPy adds on top of Docker Mailserver:**
- Web interface for alias and domain management
- Automatic DNS configuration (MX, SPF, DKIM, DMARC)
- Message search and web inbox
- REST API and webhooks
- MCP Server for AI integrations
- Multi-tenant with team roles

**Deployment in one command:**
```bash
git clone https://github.com/larrymotalavigne/smtpy
cp .env.selfhosted.example .env.selfhosted
# Edit: DOMAIN, POSTGRES_PASSWORD, SECRET_KEY
docker compose -f docker-compose.selfhosted.yml --env-file .env.selfhosted up -d
```

---

## Glossary

### SPF (Sender Policy Framework)

SPF is an email authentication mechanism published as a DNS TXT record. It lists the IP addresses and servers authorised to send emails on behalf of your domain.

When a server receives an email from `contact@yourdomain.fr`, it queries the SPF record of `yourdomain.fr`. If the sending server's IP is listed, the email is considered legitimate. Otherwise, it may be rejected or flagged as spam.

Example SPF record syntax:
```
v=spf1 include:spf.smtpy.fr ~all
```

- `v=spf1` — protocol version
- `include:spf.smtpy.fr` — authorises SMTPy's servers
- `~all` — softfail (suspicious but not blocked)
- `-all` — hardfail (rejected)

SPF does not protect against falsification of the visible "From" header (it only checks the "Return-Path"). This is why SPF must be combined with DKIM and DMARC.

SMTPy generates the correct SPF record automatically when you add a domain.

---

### DKIM (DomainKeys Identified Mail)

DKIM is an email authentication protocol that uses public-key cryptography to verify the integrity and origin of an email. Each outgoing email receives a digital signature that the recipient server can validate.

How it works:
1. The sending server signs the email with a **private key**
2. The signature is added to the email's DKIM header
3. The recipient server retrieves the **public key** from DNS
4. It verifies the signature — proving the email has not been altered

Example DNS record:
```
mail._domainkey.yourdomain.fr  IN  TXT  "v=DKIM1; k=rsa; p=MIGfMA0..."
```

DKIM protects the email content against modification in transit and validates the visible "From" header (unlike SPF). It is essential for email deliverability.

SMTPy generates the RSA key pair automatically and provides the DKIM DNS record ready to copy. Key rotation is handled automatically.

---

### DMARC (Domain-based Message Authentication, Reporting and Conformance)

DMARC builds on SPF and DKIM to define the authentication policy for your domain and receive reports on emails sent in your name.

The three DMARC policies:
- `p=none` — monitoring only: no corrective action, but you receive reports
- `p=quarantine` — failing emails go to the spam folder
- `p=reject` — failing emails are permanently rejected

Example DMARC record:
```
_dmarc.yourdomain.fr  IN  TXT  "v=DMARC1; p=quarantine; rua=mailto:dmarc@yourdomain.fr; pct=100"
```

- `p=quarantine` — policy applied
- `rua=` — address for aggregate report delivery
- `pct=100` — apply the policy to 100% of emails

SMTPy configures a `p=none` DMARC record initially so you receive reports without blocking legitimate emails. You can tighten the policy after reviewing reports.

---

### MX Record

An MX (Mail Exchanger) record is a DNS record that specifies which mail server accepts email for a domain. Without a valid MX record, emails sent to `anything@yourdomain.com` bounce immediately.

Example MX record:
```
yourdomain.fr  IN  MX  10  mail.smtpy.fr
```

- `10` — priority (lower = higher priority); multiple MX records can exist for redundancy
- `mail.smtpy.fr` — the mail server that receives email for `yourdomain.fr`

SMTPy generates the MX record automatically when you add a domain. You copy-paste it into your registrar's DNS panel.

---

### Email Alias

An email alias is a secondary address that automatically redirects messages to a real inbox. The recipient's real address remains invisible to senders.

Key properties:
- Aliases are not real inboxes — they are routing rules
- Multiple aliases can forward to the same real address
- An alias can be disabled instantly (no more emails) without deleting it
- An alias can forward to multiple destinations simultaneously

Use cases:
- `newsletter@yourdomain.com` — subscribe to newsletters; disable when overwhelmed
- `contact@yourdomain.com` — public business address
- `amazon@yourdomain.com` — track which service leaked your email

SMTPy extends the basic alias concept with a full web inbox: you can read, reply, and compose from the alias address, not just receive forwarded emails.

---

### Catch-All

A catch-all (or wildcard address) routes all emails sent to any address on a domain — including non-existent ones — to a single destination.

Example: with a catch-all on `yourdomain.com`, emails to `anything@yourdomain.com`, `foo@yourdomain.com`, or `xkcd@yourdomain.com` all arrive at your inbox, even if those aliases do not exist.

**Benefit:** you can create ad-hoc aliases without pre-registering them. Give `uniquecode@yourdomain.com` when registering on a new website; if you receive spam on it, you know that site was compromised.

**Downside:** catch-alls attract more spam because spammers can enumerate random addresses. Use with good spam filtering (SMTPy uses Rspamd).

---

### Email Forwarding

Email forwarding is the process of automatically redirecting an email from one address to another. When a message arrives at `contact@yourdomain.fr`, forwarding sends a copy to `you@gmail.com`.

Types of forwarding:
- **Simple redirect** — the email is sent to the destination unchanged
- **Alias forwarding** — the From header is preserved; replies go back to the original sender
- **Masked forwarding** — the alias address is shown as the sender; replies go through the alias

SMTPy uses masked forwarding: your real address is never revealed, and replies sent from your real inbox appear to come from the alias address.

---

### SMTP (Simple Mail Transfer Protocol)

SMTP is the protocol used to send emails between mail servers and from email clients to mail servers. It operates on port 25 (server-to-server), port 587 (authenticated client submission), and port 465 (SMTPS with SSL).

SMTP handles outgoing email only. Receiving email uses IMAP or POP3.

SMTPy uses SMTP to forward messages from the alias to the destination inbox, and for the transactional Send API (`POST /send`).

---

### IMAP (Internet Message Access Protocol)

IMAP is the protocol used by email clients (Outlook, Thunderbird, Apple Mail) to retrieve and manage emails from a mail server. Unlike POP3, IMAP keeps emails on the server and synchronises state (read/unread, folders) across all devices.

IMAP operates on port 143 (plain) and port 993 (IMAPS with SSL).

SMTPy's web inbox is not an IMAP client — it reads directly from its PostgreSQL database where messages are stored after forwarding. For native IMAP access to your aliases, you would need Dovecot configured (included in the self-hosted Docker Mailserver stack).

---

### Email Bounce

An email bounce occurs when a delivery attempt fails and the message is returned to the sender. There are two types:

**Hard bounce** — permanent failure: the recipient address does not exist, or the domain has no MX record. The message is never delivered.

**Soft bounce** — temporary failure: the recipient's inbox is full, or the server is temporarily unavailable. Delivery is retried for a period before giving up.

SMTPy's dashboard shows delivery status (DELIVERED, FAILED, PENDING, REJECTED) for every message. Failed messages can be retried manually. The `email_retry_job.py` background job automatically retries soft-bounce failures.

---

### Email Deliverability

Deliverability is the probability that an email you send arrives in the recipient's inbox rather than the spam folder or being rejected entirely.

Key factors affecting deliverability:
1. **SPF** — sending IP is listed in your DNS SPF record
2. **DKIM** — email is signed with a valid private key
3. **DMARC** — authentication policy is published and passing
4. **Sender reputation** — the sending IP's history (new IPs need warmup)
5. **Content** — spam-triggering words, excessive links, HTML-to-text ratio
6. **Bounce rate** — high bounce rates signal a low-quality list
7. **Unsubscribe handling** — must honour unsubscribes quickly

SMTPy configures SPF, DKIM, and DMARC automatically. Rspamd scores outgoing emails and blocks likely spam before it is sent. The analytics dashboard shows delivery rates per domain so you can spot deliverability issues early.

---

## FAQ

**What is an email alias?**
An email alias is a secondary address that automatically redirects messages to your real inbox. Your real address remains invisible to senders. You can disable it at any time.

**Can I use my own domain with SMTPy?**
Yes — that is the core premise. Add your domain in SMTPy; it generates the DNS records (MX, SPF, DKIM, DMARC) you paste into your registrar. Verification is automatic.

**Is SMTPy free?**
SMTPy has a free plan: 1 domain, 5 aliases, 100 emails/month. No credit card required. The Pro plan is 9€/month with 5 domains, unlimited aliases, and 10,000 emails/month.

**Where is my data hosted?**
SMTPy is self-hosted — you install it on your own server with one Docker command. The public service at smtpy.fr is hosted in France, subject to French law and the European GDPR.

**Is SMTPy open source?**
Yes. SMTPy is fully open source (MIT). Source code: https://github.com/larrymotalavigne/smtpy. You can audit, modify, and deploy it freely.

**How is SMTPy different from SimpleLogin?**
SMTPy is self-hosted (your data on your server), includes a full web inbox for reading and replying to emails, and offers a custom domain on the free plan. SimpleLogin was acquired by Proton in 2022 and is now hosted on Proton's infrastructure.

**Is running your own mail server complicated?**
Docker Mailserver handles the hard parts: Postfix, Dovecot, Rspamd, ClamAV. SMTPy adds the web interface, DNS management, and API. Total setup time is under 30 minutes for someone comfortable with Docker.

**How many aliases can I have on the free plan?**
The free plan includes 1 domain, 5 aliases, and up to 100 emails per month. The Pro plan (9€/month) offers 5 domains, unlimited aliases, and 10,000 emails/month.

**Is SMTPy compatible with all DNS registrars?**
Yes. SMTPy generates standard DNS records (MX, TXT for SPF, CNAME for DKIM, TXT for DMARC) compatible with all registrars: OVH, Gandi, Namecheap, Cloudflare, Google Domains, Ionos, etc.

**Can I cancel at any time?**
Yes, with no commitment or penalty. Downgrade to the free plan or delete your account at any time from profile settings. GDPR data export and deletion are built-in.

**Can I reply to emails from my alias?**
Yes. The SMTPy web inbox lets you reply directly. The reply appears to come from your alias address — your real address is never revealed to the recipient.

**Does SMTPy have push notifications?**
Yes. SMTPy is a PWA (Progressive Web App) and supports push notifications for new emails and first-contact sender alerts.

---

## Self-Hosting

### Quick start

```bash
git clone https://github.com/larrymotalavigne/smtpy
cd smtpy
cp .env.selfhosted.example .env.selfhosted
# Edit .env.selfhosted: set DOMAIN, POSTGRES_PASSWORD, SECRET_KEY
docker compose -f docker-compose.selfhosted.yml --env-file .env.selfhosted up -d
```

### Requirements

- A domain name with access to DNS settings
- A server with at least 2 vCPUs, 2 GB RAM, 20 GB disk
- Docker and Docker Compose installed
- Port 25 open (check your hosting provider — many block port 25 by default)

### What gets deployed

| Container | Purpose |
|-----------|---------|
| `smtpy-api` | FastAPI backend (Python) |
| `smtpy-front` | Angular frontend (nginx) |
| `smtpy-smtp-receiver` | SMTP receiver on port 2525 |
| `smtpy-db` | PostgreSQL 16 |
| `smtpy-redis` | Redis (sessions, rate limiting, job locking) |
| `mailserver` | Docker Mailserver (Postfix, Dovecot, Rspamd, ClamAV) |

### Architecture

External email arrives at port 25 on the mailserver. Postfix looks up the alias in PostgreSQL. If the alias is active, the email is routed to `smtp-receiver:2525`. The SMTP handler processes the message, applies forwarding rules, stores it in PostgreSQL, and forwards it via the mailserver's authenticated SMTP on port 587.

---

## Links

- Homepage: https://smtpy.fr
- GitHub: https://github.com/larrymotalavigne/smtpy
- API docs: https://api.smtpy.fr/docs
- API reference (LLM): https://smtpy.fr/llms.txt
- Register: https://smtpy.fr/auth/register
- Blog: https://smtpy.fr/blog
- Comparisons: https://smtpy.fr/vs/simplelogin, https://smtpy.fr/vs/annaddy
- Glossary: https://smtpy.fr/glossary