KumoMTA Setup: High-Volume Self-Hosted Sending

When You Need KumoMTA

Mailcow and Postal work great up to 200K-500K emails/month. Beyond that, you need an MTA purpose-built for volume.

KumoMTA fills the gap between packaged email servers and commercial MTAs like PowerMTA ($15,000+ license):

MTA	Cost	Best Volume Range	Complexity
Mailcow (Postfix)	Free	Up to 200K/month	Low
Postal	Free	Up to 500K/month	Low
KumoMTA	Free	500K-10M+/month	Medium
PowerMTA	$15,000+	1M+/month	High

If you're sending 500K+ emails/month and don't want to pay for PowerMTA, KumoMTA is the answer. See our MTA comparison for a full overview.

Requirements

• VPS/Dedicated: 4GB RAM minimum, 8GB+ recommended
• OS: Ubuntu 22.04, Debian 12, Rocky Linux 9
• Fast disk: SSD required for queue performance
• Clean IPs: Multiple IPs recommended for volume (IP pools)
• Port 25 open: Required for outbound SMTP

At high volume, consider a dedicated server over a VPS. Hetzner dedicated servers with 32GB+ RAM start at ~$40/month.

Installation

Add the KumoMTA Repository

# Ubuntu/Debian
curl -fsSL https://openrepo.kumomta.com/kumomta-public-key.gpg | gpg --dearmor -o /usr/share/keyrings/kumomta-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/kumomta-archive-keyring.gpg] https://openrepo.kumomta.com/apt $(lsb_release -cs) main" > /etc/apt/sources.list.d/kumomta.list
apt update
apt install kumomta -y

Configuration via Lua

KumoMTA uses Lua scripts for configuration. This is more flexible than config files but requires learning Lua basics.

Create /opt/kumomta/etc/policy/init.lua:

local kumo = require 'kumo'

kumo.on('init', function()
  kumo.define_spool {
    name = 'data',
    path = '/var/spool/kumomta/data',
  }
  kumo.define_spool {
    name = 'meta',
    path = '/var/spool/kumomta/meta',
  }

  -- SMTP listener for injection
  kumo.start_esmtp_listener {
    listen = '0.0.0.0:587',
    hostname = 'mail.yourdomain.com',
  }

  -- HTTP API for injection
  kumo.start_http_listener {
    listen = '0.0.0.0:8000',
  }
end)

DKIM Signing

kumo.on('smtp_server_message_received', function(msg)
  msg:dkim_sign(kumo.dkim_sign {
    domain = msg:from_header().domain,
    selector = 'default',
    headers = { 'From', 'To', 'Subject', 'Date' },
    key = string.format('/opt/kumomta/etc/dkim/%s/default.key', msg:from_header().domain),
  })
end)

Generate DKIM keys:

mkdir -p /opt/kumomta/etc/dkim/yourdomain.com
openssl genrsa -out /opt/kumomta/etc/dkim/yourdomain.com/default.key 2048
openssl rsa -in /opt/kumomta/etc/dkim/yourdomain.com/default.key -pubout -outform der 2>/dev/null | openssl base64 -A

IP Pool Management

KumoMTA's strongest feature for high-volume sending: IP pools with per-ISP routing.

kumo.on('get_queue_config', function(domain, tenant, campaign)
  return kumo.make_queue_config {
    egress_pool = 'pool-marketing',
    max_deliveries_per_connection = 20,
  }
end)

kumo.on('get_egress_pool', function(pool_name)
  return kumo.make_egress_pool {
    name = 'pool-marketing',
    entries = {
      { name = 'ip1', source = '203.0.113.1' },
      { name = 'ip2', source = '203.0.113.2' },
      { name = 'ip3', source = '203.0.113.3' },
    },
  }
end)

This rotates sending across three IPs automatically. KumoMTA handles the rotation, per-IP throttling, and failover.

Practitioner note: KumoMTA's IP pool management is where it earns its keep. At 1M+ emails/month, you need multiple IPs with intelligent rotation. Doing this with raw Postfix requires custom scripts and constant tuning. KumoMTA handles it natively.

Per-ISP Throttling

Different ISPs accept email at different rates. Gmail, Outlook, and Yahoo each have their own undocumented thresholds. KumoMTA lets you tune per-destination:

kumo.on('get_queue_config', function(domain, tenant, campaign)
  if domain == 'gmail.com' or domain == 'googlemail.com' then
    return kumo.make_queue_config {
      max_deliveries_per_connection = 10,
      max_connection_rate = '5/minute',
    }
  end
  return kumo.make_queue_config {
    max_deliveries_per_connection = 20,
  }
end)

This prevents you from exceeding ISP rate limits and getting temporarily blocked. Commercial MTAs charge thousands for this capability.

Bounce Processing

KumoMTA classifies bounces automatically and provides hooks for custom handling:

kumo.on('smtp_server_message_bounced', function(msg, bounce)
  -- Log bounce for list cleanup
  -- Integrate with your CRM/database
end)

Automated bounce processing is critical at high volume. Without it, you keep sending to invalid addresses and destroy your IP reputation.

Practitioner note: The Lua configuration has a learning curve, but it's dramatically more powerful than Postfix's config file syntax. Once you're comfortable with it, KumoMTA becomes the most flexible MTA available at any price point. I've replaced $15K PowerMTA licenses with KumoMTA for three clients — same functionality, zero license cost.

DNS Configuration

Standard email DNS records apply. See the DNS configuration guide for each record.

For multiple sending IPs, add SPF entries for each:

v=spf1 ip4:203.0.113.1 ip4:203.0.113.2 ip4:203.0.113.3 -all

Set PTR records for every sending IP.

Starting KumoMTA

systemctl start kumomta
systemctl enable kumomta

Inject a test message via the HTTP API:

curl -X POST http://localhost:8000/api/inject/v1 \
  -H "Content-Type: application/json" \
  -d '{"envelope_sender":"[email protected]","recipients":["[email protected]"],"content":"Subject: Test\r\n\r\nTest message"}'

When KumoMTA Is Overkill

If you're sending under 500K/month, KumoMTA's complexity isn't justified. Use:

• Under 100K/month: Mailcow
• 100K-500K/month: Postal or Mailcow
• 500K+/month: KumoMTA

Practitioner note: Don't deploy KumoMTA because it sounds cool. Deploy it because you've outgrown Mailcow's sending capacity or need per-ISP throttling and IP pool management. It's a volume tool, not a general-purpose email server.

If you need help deploying and tuning KumoMTA for high-volume sending, schedule a consultation — I configure KumoMTA for businesses sending 500K-10M+ emails/month.

Sources

• KumoMTA: Official Documentation
• KumoMTA: GitHub Repository
• KumoMTA: Configuration Reference
• RFC 5321: Simple Mail Transfer Protocol

---

v1.0 · April 2026