Robin Suite

Robin MTA / Transport & Testing

Move the mail.
Inspect the pipeline.

SMTP transport for your mail stack, with a programmable client and test engine for understanding delivery behavior.

Run Robin with Dovecot, Rspamd, and ClamAV. Reproduce protocol quirks in a controlled lab, then assert on SMTP, logs, IMAP, APIs, MIME, and TLS.

Deploy Robin MTAView Source

SMTP transport · Java 21 · Apache 2.0

Robin MTA mascot

Three Parts of the MTA Toolkit

Transport, reproduce, verify.

Use the server for mail transport, the client for protocol control, and the test engine for repeatable delivery assertions.

Transport

SMTP Server

Dovecot integration, durable queues, scanning, policy webhooks, diagnostic bots, and service APIs.

Explore the Server
Reproduce

Programmable SMTP Client

Control TLS, chunking, timing, and socket behavior to reproduce real-world interoperability failures.

Explore the Client
Verify

JSON Test Engine

Run delivery assertions in CI or synthetic monitoring, inspecting more than the SMTP response.

Explore the Test Engine

The SMTP Client

Reproduce the bug.
Don't guess it.

Robin's SMTP client is controllable right down to the TCP writes. That's what lets it impersonate the precise misbehaviour of a real ESP and turn a flaky, unreproducible interop bug into a deterministic test.

TLS & cipher control

Offer only the protocols and ciphers you choose — force TLSv1.0 and a weak cipher to reproduce a handshake failure.

CHUNKING / BDAT framing

Set the BDAT chunk size and split it across uneven TCP writes — exactly how different providers frame the wire.

Connection injection

Cut the connection after N bytes, or right before or after the final <CRLF>.<CRLF> — mid-DATA disconnects on tap.

Slow-sender emulation

Add write delays every N bytes to emulate a slowloris or a struggling upstream.

AUTH quirks

AUTH-before-STARTTLS, combined LOGIN on one line, auth retries — replay the vulnerable behaviours clients really ship.

XCLIENT & custom params

Forge client identity with XCLIENT and inject arbitrary MAIL/RCPT parameters for proxy and filter testing.

The SMTP Server

Mail transport.
With a testable pipeline.

Use Robin for SMTP transport with Dovecot mailbox integration, spam and virus scanning, queue persistence, and service APIs. Configure explicit scenarios to reproduce failures and inspect each stage of the pipeline.

Failure scenarios

Return custom responses per domain and per verb — 501 at EHLO, 554 at DATA, per-recipient regex replies.

Chaos headers

Force the AV, spam, storage or Dovecot processor to fail on a single message — clean fault injection without breaking real services.

Diagnostic bots

Send a message and get a diagnostic reply: a session summary with JSON evidence, or an email-analysis report covering DNS, reputation, receiving infrastructure, TLS, and authentication results from Rspamd.

Explore Diagnostic Bots

DoS protection

Configurable connection and rate limits, progressive tarpitting, and slow-sender guards, with operational metrics.

Durable queues

Choose MapDB, Redis, MariaDB, or PostgreSQL storage. Retry with back-off, recover expired delivery leases, and inspect or retry queued messages through the API.

Explore Queue Storage

Metrics everywhere

Micrometer to Prometheus & Graphite, plus Prometheus remote-write push to VictoriaMetrics, Mimir or Thanos.

ClamAV & Rspamd

Virus and spam scanning with separate reject and discard thresholds, symbol extraction and optional DKIM signing.

Webhooks that decide

Put application policy in the SMTP conversation. Per-command callbacks can return temporary or permanent SMTP decisions; a separate raw-message callback sends stored content to downstream services.

Explore Policy Webhooks

Mail-report ingestion

Parse incoming DMARC, TLS-RPT, and forensic reports and forward normalized JSON to your own HTTP endpoint. Connect mail evidence to your reporting workflow.

Explore Report Bots

The Test Engine

From SMTP conversation
to verified mailbox delivery.

Define a JSON5 scenario, assert protocol responses, follow delivery logs, and inspect the message that arrives over IMAP. Run cases from Java/JUnit for CI pass/fail reporting, or use the CLI for repeatable investigations.

Beyond SMTP codes

  • Logs — find delivery evidence, match patterns, and capture values into variables.
  • IMAP — log in and prove the message landed: match headers, MIME parts, decoded body, even content hashes.
  • HTTP APIs — GET/POST/PUT/DELETE against your own endpoints and match JSON or text response content.
  • Negotiated TLS — assert the exact protocol and cipher that were used.

The magic system threads data through a whole test — capture a UID from a log line and assert on it in the next envelope. Build MIME on the fly, including generated PDFs, with auto Message-ID and Date.

{
  "mail": "{$mail}",
  "rcpt": ["{$rcpt}"],
  "assertions": {
    "protocol": [
      ["MAIL", "250 "],
      ["RCPT", "250 "],
      ["DATA", "250 Received"]
    ],
    "external": [
      { "type": "imap", "folder": "INBOX",
        "wait": 5, "retry": 6,
        "match": { "message-id": "{$MSGID}" },
        "delete": true },
      { "type": "logs",
        "grep": [["Custody=true", "Storage=check"]],
        "refuse": ["NullPointerException"] }
    ]
  }
}

Inspect the Delivered Content

Locate mail by Message-ID, match headers and decoded MIME parts, and check attachment hashes. Configure polling for delivery and remove verified test messages after successful checks.

IMAP Verification

Chain Evidence Across Steps

Capture an identifier from a delivery log or HTTP response and reuse it in later checks. Ordered external assertions and dynamic variables connect submission, processing, and delivery evidence.

Workflow Variables

Generate Realistic Fixtures

Build nested MIME messages, encoded bodies, file attachments, and dynamic PDFs at runtime. Vary dates, identifiers, text, and images to exercise scanners and content pipelines.

Message & PDF Fixtures

Reproduce Failure Paths

Vary BDAT chunks and write timing, interrupt DATA transfers, or inject controlled downstream failures. Exercise rejection and storage errors as deliberately as successful delivery.

End-to-End Scenarios

Model Real Mail Traffic

Send multiple envelopes and recipients, repeat deliveries, select fixture folders, and choose deterministic routes. Assert greeting, EHLO capabilities, authentication, recipient decisions, and negotiated TLS.

SMTP Scenario Controls

Include Your Mail APIs

Combine SMTP evidence with HTTP requests, form fields, and multipart uploads. Match response content and capture values for later assertions; use the send API separately to submit cases or raw EML.

HTTP Workflow Integration

In production, Robin runs as synthetic monitoring across 25+ environments every three hours — submitting mail, reading it back over IMAP, checking protocol responses and delivery, and alerting Slack the moment anything drifts.

Build With Robin

Single responsibility.
Reusable libraries.

Robin is built to come apart. Every piece is a standalone, Apache-2.0 Java library you can drop into your own tools.

Deploy the Transport

A mail stack.
Or a controlled test environment.

Choose the deployment for your use case. Mail transport and intentional fault injection need different configurations.

Self-Hosted Mail

Run With the Robin Suite

Start Robin MTA alongside Dovecot, Rspamd, ClamAV, PostgreSQL, and Redis. Add Admin and Tools as separate deployments when you need operations and diagnostics.

docker compose -f .suite/docker-compose.yaml up -d
Mail Stack Deployment Guide Complete Suite Setup

Follow the mail-stack or testing guide for the configuration that fits your use case.

Part of the Robin Suite

Transport is one part of the picture.

Operate supported services with Robin Admin, or investigate DNS and mail posture with Robin Tools.

Explore Robin Admin Explore Robin Tools Meet the Suite