VirtuProbe Studio
Get the app

Protocol · SMTP

SMTP testing, command by command.

Send the SMTP conversation yourself — greeting, auth, envelope, body — and check what the server says back at each step. No mail client sitting between you and the wire.

VirtuProbe's SMTP probe is the raw conversation, not a "send mail" button. You compose the command sequence, set an expected reply code on each command, and see the server's exact response. It's the tool for building a mail path, debugging a relay, or checking that a server rejects what it's supposed to reject.

01Drive the whole conversation

Each command is configured on its own, so you decide exactly what goes on the wire and in what order. The supported command types cover a normal session and the awkward parts around it:

  • EHLO / HELO — open the session and read the server's capabilities.
  • MAIL_FROM, RCPT_TO — set the envelope sender and recipients.
  • DATA and DATA_BODY — start the message, then send the dot-stuffed body.
  • STARTTLS — upgrade the plaintext connection to TLS mid-session.
  • AUTH — authenticate with PLAIN or LOGIN.
  • RSET, NOOP, VRFY, QUIT — reset, keep-alive, verify, close.
  • CUSTOM — send anything else verbatim.

Connect on port 25, 587 or 465; tick SSL/TLS to start encrypted from the first byte (465), or use STARTTLS to upgrade a plaintext session.

02Auth, TLS, and the message body — without the busywork

The parts that are fiddly by hand have helpers:

  • The AUTH helper builds the base64 PLAIN/LOGIN credential string and drops it into the command for you.
  • The MIME composer assembles a valid RFC 5322 message — From, To, Subject, body — for the DATA_BODY command, so you're not hand-rolling headers.
  • {{variables}} resolve in the host and in every command's data field, so a probe can be reused across environments.
# SMTP probe: authenticated relay smoke test

EHLO        mail.example.com                 expect 250
STARTTLS                                     expect 220
AUTH        PLAIN {{authToken}}              expect 235
MAIL FROM   <{{sender}}>                     expect 250
RCPT TO     <{{recipient}}>                  expect 250
DATA                                         expect 354
DATA_BODY   (MIME message)                   expect 250
QUIT                                         expect 221

03Assert on the reply, extract what you need

Set an expected response code per command — 250, 235, 354, 221 — and a mismatch marks that exchange (and the run) failed. Then pull values out with two extractors:

  • SMTP_SUCCESStrue when the whole exchange completed with no failed assertion. The one-line "did it work" signal for a chain.
  • SMTP_EXCHANGE_LINES — the server's reply lines for a chosen command (or the greeting), joined into a variable. Point it at EHLO to capture the advertised capabilities and assert on them downstream.
On malformed input: VirtuProbe implements SMTP against the RFC by hand, so it sends the commands you write, in the order you write them — a library won't quietly "correct" a deliberately-wrong command before it reaches the wire. Structural mutation fuzzing is currently HTTP-only; the SMTP probe is about precise, hand-authored exchanges.

04Put it in a chain

SMTP is a first-class chain step (and callable from Groovy scripts), so it composes with everything else. The obvious pairing: deliver a message over SMTP, then confirm it arrived over IMAP — or score it through SpamAssassin — in a single run, passing values between steps with {{variables}}.

Need a target to test against? MailHog and GreenMail are common throwaway SMTP servers for exactly this, and both appear as ready-made probes in the community library.

Send your first SMTP conversation. VirtuProbe Studio is free to download — no account, no cloud, no telemetry. The SMTP probe, chaining and request history are on the free tier.

Join our Discord