Listmonk Automation: Drip Campaigns, Transactional Email, Limits

Listmonk is a newsletter and mailing list manager, not a marketing automation platform, and it does not pretend otherwise. It has no built-in drip campaigns, no visual journey builder, and no event-triggered sequences. What it does have is a complete REST API, a transactional email endpoint, SQL-based segmentation, and bounce webhooks, which together cover most of the automation a small team actually needs. This post maps exactly what Listmonk automates natively, how to build welcome series and drip sequences on top of its API, what it costs to run, and the point where you should stop and use Mautic or a SaaS tool instead.

If you have not set Listmonk up yet, start with our guide to self-hosting a newsletter with Listmonk and Amazon SES and come back here when it is running.

What Listmonk automates out of the box

Listmonk is a single Go binary backed by PostgreSQL, licensed AGPL v3, with over 24,000 stars on GitHub. For a tool its size, it automates more than most people expect:

• Double opt-in. When someone subscribes, Listmonk sends a confirmation email automatically using the subscriber-optin system template. No configuration beyond enabling it on the list.
• Opt-in campaigns. You can send a confirmation campaign to unconfirmed subscribers directly from the lists page.
• Bounce processing. Listmonk scans a dedicated POP3 bounce mailbox, classifies bounces as hard or soft using status codes and body heuristics, and can receive bounce events through inbound webhooks, including a native Amazon SES endpoint at /webhooks/service/ses. Subscribers that cross your bounce threshold get blocklisted automatically.
• Subscription management. Hosted pages for subscribing, managing preferences, exporting personal data, and wiping it. Useful for GDPR-style requests with zero code.
• Campaign scheduling. Any campaign can be scheduled to start at a future time.
• Dynamic segmentation. Segments are SQL expressions evaluated at send time, not static exports. More on this below, because it is quietly the most powerful automation feature in the product.

That is the full native list. Anything involving a sequence of messages over time, a trigger based on subscriber behaviour, or branching logic has to be built on the API.

Transactional email with the /api/tx endpoint

Listmonk ships a transactional API that most newsletter-focused write-ups skip. One endpoint, POST /api/tx, sends a message through a preconfigured transactional template to one or more recipients:

curl -u "api_user:token" "http://localhost:9000/api/tx" -X POST \
     -H 'Content-Type: application/json; charset=utf-8' \
     --data-binary @- << EOF
    {
        "subscriber_email": "user@test.com",
        "template_id": 2,
        "data": {"order_id": "1234", "date": "2026-10-28", "items": [1, 2, 3]},
        "content_type": "html"
    }
EOF

Three details matter in practice:

• Subscriber modes. The default mode requires the recipient to exist in your Listmonk database. The fallback and external modes send to any address without a database lookup, with data passed in as JSON and rendered in the template as {{ .Tx.Data.* }}. Use external mode only for genuine transactional mail like receipts and password resets. Marketing mail needs real subscribers so unsubscribe links and blocklisting work.
• Attachments. Send with multipart/form-data and attach files with repeated file parameters. Invoices and tickets as PDFs work fine.
• Messengers. The messenger parameter routes the message through a non-email backend if you have one configured.

For many applications this endpoint replaces a second transactional service entirely. Your app calls Listmonk, Listmonk sends through SES, and opens, templates, and sending rules live in one place.

Building a drip sequence with the Listmonk API

Everything on the Listmonk dashboard is available as a REST API with BasicAuth or token authentication, and there is a generated OpenAPI spec. A drip sequence is a scheduled job that finds the right subscribers and triggers the right send. There is an open feature request for a native subscription-triggered welcome email, so this is a known gap, not an oversight in your reading of the docs.

Here is a pattern that works for a four-email welcome series:

1. Add a step attribute. Every subscriber gets a numeric attribute, for example welcome_step, starting at 0 when they join.
2. Create one transactional template per email. Four templates, one per step, each with its own subject and body.
3. Run a scheduler. An n8n workflow or a cron job fires daily and asks the Listmonk API for subscribers in the welcome list whose welcome_step and created_at say they are due for the next email.
4. Send and stamp. For each due subscriber, call /api/tx with the template for their current step, then PUT /api/subscribers/{id} to increment welcome_step.

The timing logic lives in the scheduler, where you can see it and change it, instead of inside a black-box automation tool. If you already run n8n for other work, this is a small addition; our post on connecting a self-hosted stack with n8n and webhooks covers the plumbing. We also build and maintain exactly these workflows as part of our business automation service.

Two honest warnings about this pattern. First, /api/tx sends immediately and one call per subscriber, so a 50,000-subscriber daily batch means 50,000 API calls. Fine at thousands, clumsy at tens of thousands. Second, per-recipient send-time optimization does not exist here. Everyone in the batch goes out when the cron fires.

For large one-to-many sequences, a better shape is the campaigns API: create a campaign programmatically against a dynamic segment, then start it. The segment does the filtering, Listmonk does the bulk sending, and your scheduler only decides when.

Segmentation is the quiet automation feature

Listmonk lets you write raw Postgres SQL expressions to segment subscribers, including JSONB attribute queries and engagement subqueries. Because segments are evaluated at send time, a scheduled campaign against the right expression behaves like automation.

A re-engagement segment for subscribers who joined more than 90 days ago and never opened campaign 42:

subscribers.created_at < NOW() - INTERVAL '90 days' AND
NOT EXISTS (
  SELECT 1 FROM campaign_views
  WHERE campaign_views.subscriber_id = subscribers.id
    AND campaign_views.campaign_id = 42
)

And attribute targeting, for example Nairobi-based subscribers with a specific tag:

subscribers.attribs->>'city' = 'Nairobi' AND
subscribers.attribs->'tags' ? 'trial'

Combined with scheduling, this covers a surprising amount of what people pay automation platforms for: winback campaigns, onboarding nudges to users in a specific state, upgrade prompts to accounts past a threshold. The limit is that the trigger is always time or data, never a click or a purchase event, unless your own system pushes that event into an attribute via the API first.

Beyond email: messengers

Listmonk is not email-only. Custom messenger backends let you register an HTTP service in Settings, and when a campaign runs, Listmonk POSTs each message to it as JSON with the recipient attributes. Community messengers exist for AWS Pinpoint SMS, Google FCM push, Novu, Resend, and Mailersend. Phone numbers or device tokens live in subscriber attributes.

This is useful if your audience is in a market where SMS outperforms email, which is true for a lot of East African use cases. The campaign machinery, segments, templates, and scheduling all carry over.

When Listmonk is the wrong choice

Be honest with yourself about which of these you need before committing:

• A visual journey builder. If your marketing team needs to drag decision diamonds onto a canvas, Listmonk will frustrate them within a day.
• Behavioural triggers. Send email B two hours after email A is clicked, branch on a purchase, score a lead. Not Listmonk.
• Landing pages and forms beyond a subscribe form. Not Listmonk.
• A/B testing. There is no built-in subject-line or content testing.

The open-source answer to all four is Mautic, which is a genuine marketing automation platform: visual campaign builder, lead scoring, landing pages, plugins. The trade-off is operational weight. Mautic is a PHP application with more moving parts, higher memory requirements, and meaningfully more maintenance than a single Go binary. If your real need is a newsletter plus a welcome series plus receipts, Listmonk and a scheduler are simpler and cheaper to run. If your need is lead nurturing with scoring and branching, install Mautic and skip the Listmonk workarounds.

The cost of an automated self-hosted setup

Worked example, using current Amazon SES pricing: 10,000 subscribers, a four-email welcome series, and one newsletter per week. In a heavy month every subscriber gets the full welcome series plus four newsletters, roughly 80,000 emails:

• SES Essentials plan: 80 x $0.16 per thousand = $12.80 per month. Note that new SES accounts are placed on the Essentials plan, and you can switch to a la carte pricing at any time.
• SES a la carte: 80 x $0.10 per thousand = $8.00 per month, plus $0.12 per GB of attachment data.
• VPS for Listmonk, PostgreSQL, and n8n: $10 to $20 per month for a 2 vCPU instance, comfortably.
• Software: Listmonk is AGPL v3, no subscriber limits, no feature gates.

Total: roughly $20 to $35 per month, flat, regardless of list growth until you reach serious volume. The comparison with per-contact SaaS pricing is stark: a hosted platform bills you more every time your list grows, while this stack bills you the same. Our Mailchimp to Listmonk migration guide walks through the cost math and the move itself.

Common mistakes

• Using the transactional endpoint for bulk sends. One API call per recipient does not scale and gives you no campaign-level analytics. Use campaigns against segments for anything over a few thousand recipients.
• Skipping the bounce webhook. If SES bounce events never reach Listmonk, you keep mailing dead addresses, your sender reputation erodes, and SES will eventually suspend you. Wire /webhooks/service/ses on day one and follow the usual deliverability practices for self-hosted email: SPF, DKIM, DMARC, and a proper warm-up.
• Abusing Sprig in templates. Listmonk templates support 100+ Sprig functions and are Turing-complete. The docs warn explicitly that a bad template can exhaust host memory. Restrict template editing permissions to people you trust with production.
• Using external subscriber mode for marketing. Recipients outside the database have no subscription record, no working unsubscribe link, and no bounce blocklisting. That is how you become a spammer by accident.
• Automating before fixing the basics. A clever drip sequence on a dirty list with no double opt-in automates the sending of email nobody wants. Clean the list first; our Mailchimp to Listmonk migration guide covers the hygiene steps.

Frequently asked questions

Can Listmonk send a welcome email automatically?

Not natively. Listmonk sends double opt-in confirmation emails automatically, but a timed welcome series is an open feature request on GitHub, not a shipped feature. The practical workaround is a scheduler, cron or n8n, calling the API as described above.

Does Listmonk have an API?

Yes, and it is complete. Every dashboard feature is available as a JSON REST API with token auth, and there is a generated OpenAPI specification. Campaigns, subscribers, lists, templates, transactional sends, and bounces are all scriptable.

Can Listmonk replace Mailchimp automation?

For newsletters, welcome series, and transactional mail, yes, with the scheduler pattern in this post. For visual multi-step journeys, behavioural triggers, and lead scoring, no. That territory belongs to Mautic on the open-source side or a SaaS automation tool.

Should I self-host Listmonk or Mautic?

Listmonk if your core need is sending email well and cheaply: one binary, one database, minimal maintenance. Mautic if your core need is marketing automation with branching logic, scoring, and landing pages, and you accept the heavier PHP stack and upkeep that come with it.

How much does it cost to automate email with Listmonk and SES?

For 10,000 subscribers receiving around 80,000 emails a month, expect $8 to $13 in SES fees plus $10 to $20 for a VPS, so roughly $20 to $35 per month all in. The software itself is free under AGPL v3.

Can Listmonk send SMS or push notifications?

Yes, through custom messengers. Listmonk POSTs campaign messages as JSON to an HTTP service you register, and community messenger implementations exist for AWS Pinpoint SMS, Google FCM, Novu, and others.

Where to go from here

Listmonk rewards a builder mindset: the product gives you solid primitives, and the API turns those primitives into whatever automation your business actually needs, without a per-contact tax. If you would rather have the stack deployed, wired to SES, and maintained for you, including the drip workflows on top, that is exactly what our managed open-source stack service does for Listmonk and the tools around it.