Notifuse

Notifuse is a modern, self-hosted emailing platform that gives developers and marketers complete control over their email infrastructure. Built with Go and React, it delivers enterprise-grade marketing and transactional email capabilities — visual drag-and-drop builder, A/B testing, contact segmentation, automation workflows, and a full transactional API — without the ongoing SaaS subscription costs or data privacy concerns of hosted alternatives.

The platform is multi-tenant by design: each workspace gets isolated contacts, templates, campaigns, analytics, and provider integrations, making it equally suited for agencies running client accounts or product teams managing multiple environments. An embedded AI email assistant (backed by Anthropic Claude or OpenAI) can draft, refine, and populate email content with live data fetched from URLs — all streamed to the editor in real time.

Notifuse integrates with all major email delivery providers — Amazon SES, Mailgun, Postmark, Mailjet, SparkPost, and SMTP — and includes an inbound SMTP bridge so existing mail clients and scripts can route through Notifuse without changing to an HTTP API. Webhooks conform to the Standard Webhooks specification, and an embeddable notification center widget handles user subscription preferences directly on your site or app.

Deployment targets Docker and Kubernetes via a multi-stage Dockerfile, with an interactive setup wizard for first-time configuration. The blog engine, RSS syndication, Supabase integration, and contact automation workflows extend the platform well beyond simple newsletter sending into a self-hosted customer communication hub.

What You Get

• Visual Email Builder - Drag-and-drop MJML-based editor with Tiptap rich text, real-time preview, block library, and emoji and image support for creating responsive, mobile-optimized templates.
• Transactional API - RESTful API with Bearer token authentication to send personalized emails programmatically, supporting Liquid templating variables like {{ contact.first_name }} and per-call subject overrides.
• Automation Workflows - Visual node-based automation builder with event triggers, time delays, conditional branches, per-email provider overrides for IP warming, and contact timeline tracking for every action taken.
• Contact Segmentation - Define dynamic audience segments from behavioral conditions (opens, clicks, custom events) and profile fields, with a background queue that recomputes membership automatically on relevant events.
• A/B Testing - Built-in broadcast testing for subject lines, content variants, and send times with configurable sample percentages, auto winner selection by open or click rate, and a test-completion dashboard.
• Multi-Tenant Workspaces - Isolated environments with per-workspace contacts, lists, templates, campaigns, integrations, DNS settings, and granular role-based permissions — ideal for agencies and multi-product teams.
• AI Email Assistant - Built-in LLM integration (Anthropic Claude or OpenAI) that drafts, refines, and populates email content, with server-side Firecrawl web scraping to inject live content from URLs into drafts.
• SMTP Bridge - Inbound SMTP server that accepts connections from any mail client or legacy script authenticated by API key, routing messages through the Notifuse send pipeline without requiring HTTP API changes.
• Notification Center Widget - Embeddable JavaScript widget that renders a branded preference center on your site or app, letting contacts manage list subscriptions and language preferences without leaving your product.
• Blog Engine with RSS - Built-in blog with Tiptap editor, per-workspace RSS 2.0 and JSON Feed 1.1 endpoints, category feeds, conditional GET with ETag, and admin-configurable SEO and feed settings.

Common Use Cases

• Running a paid membership newsletter - A publisher deploys Notifuse to send weekly issues to thousands of subscribers, using the visual builder and A/B testing to optimize subject lines, while keeping all subscriber data on their own server for GDPR compliance.
• Building a SaaS onboarding email sequence - A developer integrates the transactional API to send welcome emails, password resets, and in-app notifications using automation workflows triggered by custom events, with Liquid templates personalizing each message.
• Managing email for multiple client brands - An agency runs Notifuse in multi-tenant mode with separate workspaces for 20+ clients, each with their own domain, contact lists, sending provider, and analytics dashboard, billed under a single self-hosted instance.
• Migrating off Mailchimp to reduce costs - A startup exports its Mailchimp contacts to CSV, bulk-imports them into Notifuse, reconnects Amazon SES as the delivery provider, and eliminates per-email charges while retaining segmentation and campaign analytics.
• Sending transactional emails from a legacy system - A team with an existing application that uses SMTP for email connects it to the Notifuse SMTP bridge using API key credentials, gaining delivery analytics, bounce tracking, and template management with zero code changes.
• Powering a Supabase application’s email layer - A developer connects Notifuse to their Supabase project to sync contacts and send auth notifications and custom email templates through the Supabase integration, replacing the default Supabase mailer with full template control.

Under The Hood

Architecture Notifuse applies clean architecture across four vertical layers — domain, repository, service, and HTTP handlers — with the domain layer defining interface contracts that inner layers implement. This inversion makes every component independently testable and swappable without touching business logic. Dependency injection is purely constructor-based, and an application module wires the entire graph at startup, exposing typed getters for integration tests. Multi-tenancy is first-class: each workspace resolves its own isolated PostgreSQL connection pool, and an HTTP middleware enforces workspace boundaries before any handler runs. Background work (broadcast orchestration, automation scheduling, task dispatch, webhook delivery, segment recomputation) runs as goroutine-based workers that coordinate through typed task records in the database, enabling a single binary to handle both API traffic and async processing with graceful shutdown.

Tech Stack The Go 1.25 backend compiles to a static binary with CGO disabled, using the standard net/http multiplexer for HTTP routing and the Squirrel query builder with lib/pq for PostgreSQL access. MJML rendering for responsive email HTML is handled server-side via gomjml, and Liquid templating uses a custom Go port (liquidgo). An LLM subsystem dispatches streaming chat requests to either Anthropic Claude or OpenAI, tracks per-model token costs, and exposes server-side tools (Firecrawl web scraping, web search) for AI-assisted email authoring. The React 18 + TypeScript frontend uses Ant Design as its component foundation, TanStack Router and Query for navigation and data fetching, and Tiptap v3 for the rich text editor with extensive extension plugins. A second embeddable frontend — the notification center widget — is built and distributed independently. The entire stack ships as a multi-stage Docker image with separate Node.js build stages for each frontend and a minimal Alpine runtime.

Code Quality Test coverage spans the full layer stack — domain models, service logic, repository queries, and HTTP handlers — across an extensive suite of test files backed by gomock for interface mocking and go-sqlmock for database query verification without external dependencies. Race detection is enabled in CI via GitHub Actions. Error handling is explicit and typed: custom domain.ErrNotFound and domain.PermissionError types propagate through the stack via fmt.Errorf wrapping, and HTTP handlers translate error types to correct status codes rather than swallowing them. Go Report Card integration and Codecov coverage tracking reflect consistent linting and coverage discipline. The frontend applies ESLint and a strict TypeScript configuration, and the Tiptap extension system follows a declarative pattern that keeps editor action definitions — including availability checks, state queries, and execution handlers — colocated and self-contained.

What Makes It Unique Three capabilities set Notifuse apart from other open-source email platforms. Its SMTP bridge accepts inbound SMTP connections authenticated by API key and routes them through the full send pipeline, letting legacy applications and mail clients integrate without any HTTP API changes. Its webhook delivery subsystem conforms to the Standard Webhooks specification — HMAC-SHA256 signing with whsec_-prefixed secrets, versioned message IDs, and retry logic per spec — so consumers can validate delivery authenticity with standard verification code from the spec’s published libraries. Most distinctively, its AI email assistant runs as a streaming SSE endpoint that proxies to either Anthropic Claude or OpenAI, executes server-side tools (web scraping via Firecrawl, web search) to inject live content from external URLs into email drafts, and tracks per-model input and output costs in real time — making it one of the few self-hosted email platforms with a native AI authoring layer.

Self-Hosting

Notifuse is released under the GNU Affero General Public License v3.0 (AGPL-3.0). AGPL is a strong copyleft license: you can use, modify, and self-host it commercially without paying anything, but if you distribute a modified version or run it as a network service for external users, you must release your modifications under the same license. For most self-hosters — teams running it internally for their own products — AGPL imposes no practical obligations. If you build a commercial service where external customers interact with a modified Notifuse instance, a commercial license from the authors would be required.

Operationally, Notifuse requires a PostgreSQL database, an S3-compatible object store for file uploads, and at least one external email delivery provider (Amazon SES, Mailgun, Postmark, Mailjet, SparkPost, or a custom SMTP relay). A single Docker container handles both the API and all background workers. You are responsible for PostgreSQL backups, database schema migrations (which run automatically on startup), TLS termination, monitoring, and provider rate limit management. The Makefile and Docker Compose setup simplify local development, but production deployment on Kubernetes or a VPS requires you to supply secrets management, persistent volume configuration, and a reverse proxy. The SMTP bridge and task scheduler behaviors are configurable via environment variables, and the setup wizard handles first-run configuration interactively.

A managed Notifuse Cloud offering is available starting at $16 per month, which handles hosting, PostgreSQL, backups, upgrades, and availability monitoring. The self-hosted version is functionally identical to Cloud — there are no feature gates, paywalled integrations, or seat limits enforced in the open-source build. What Cloud adds is operational simplicity: automatic version upgrades, managed infrastructure, and email support with defined response expectations. Self-hosters receive community support via GitHub Issues and documentation at docs.notifuse.com, but there are no SLAs, and coordinating upgrades across major releases (which sometimes include database migrations and breaking webhook changes) is the operator’s responsibility.