Why does scanning speed matter for email deliverability?

You send 10,000 emails a minute. The first one arrives in 98ms. The last? 142ms. What happens when your spam filter takes longer than 100ms to evaluate each message?

Every millisecond counts. Email systems don't just check for spam—they must decide in under 100ms, or the pipeline stalls. That delay isn't just a lag—it triggers sender reputation risks, increases delivery failure rates, and can flag your messages as suspicious behavior.

SpamAssassin and Rspamd are both widely used open-source spam scanners, but their performance under real-world, high-throughput loads varies. When you're processing mail at scale, the speed difference between them can mean the difference between clean inbox placement and being throttled.

Key takeaways

  • SpamAssassin’s rule-heavy architecture often exceeds 100ms per message under high load, increasing the risk of delivery latency.
  • Rspamd’s modern, parallelized design typically stays under 100ms even when processing thousands of emails per minute.
  • Consistently exceeding 100ms in scanning speed can trigger automatic throttling or reputation penalties from receivers.

What are SpamAssassin and Rspamd designed to do?

SpamAssassin and Rspamd are both mail filtering systems designed to scan incoming emails for spam and malware. They analyze headers, content, DNS-based blocklists (DNSBLs), sending reputation, and other signals to assign a spam score. Messages above a threshold are flagged or rejected. While SpamAssassin has been a standard for years, Rspamd was created to be faster and more scalable, especially for high-volume environments.

SpamAssassin: The Established Rule-Based System

SpamAssassin is a mature, rule-based spam filter used by many mail servers, including older or enterprise-grade setups. It relies on a large database of rules—like keyword matches, header anomalies, and known spam patterns—to score messages. While flexible and customizable, its performance can degrade under high load due to its synchronous processing model. This makes it less ideal for modern, high-throughput email systems where milliseconds matter.

Rspamd: Built for Speed and Scale

Rspamd is a modern alternative, engineered for speed and real-time processing. It uses parallel processing, efficient caching, and a modular design to handle thousands of messages per second without slowing down. Rspamd processes DNSBLs, Bayesian analysis, reputation scores, and content scanning concurrently, making it well-suited for cloud providers, ESPs, and high-volume senders. According to the project’s documentation and performance testing (Rspamd’s official site), it consistently performs under 100ms per message even at scale.

Both systems operate with similar inputs—checking DNSBLs, header integrity, message content, and sender reputation—but Rspamd's architecture gives it a tangible edge in speed. You’ll see this difference most clearly in bulk email environments, where delayed processing can impact delivery timelines or increase latency.

For senders who need to verify the health of their email list before sending, tools like MailTester’s bulk verification screen out invalid, catch-all, or risky addresses before they cause delivery issues. This reduces sender reputation risk and keeps mail servers from being penalized. A clean list helps both SpamAssassin and Rspamd do their job more effectively by reducing noise in the queue.

How do SpamAssassin and Rspamd perform under a 100ms threshold?

Under typical load, SpamAssassin often exceeds 100ms per message—rarely hitting the mark even on modest rule sets—while Rspamd consistently stays below 50ms, even at scale. If your system needs to process thousands of emails per second with predictable latency, Rspamd’s architecture is designed to meet that standard. SpamAssassin’s single-threaded rule evaluation and dependency on Perl make it struggle under concurrent demand. Rspamd, built on C++ with a concurrent processing engine, handles high volumes without degradation.

Performance under real-world load

Let’s be clear: SpamAssassin’s performance is highly sensitive to ruleset size and system load. With a full rule set, it can take 150–200ms on modern hardware—well outside the 100ms target. This is due to its reliance on a single-threaded Perl engine, which bottlenecks under concurrency. As load increases, processing time grows non-linearly, making it unsuitable for high-throughput environments.

By contrast, Rspamd was built for performance from the start. It uses a distributed, event-driven architecture that scales linearly with CPU cores. Benchmarks from the Rspamd documentation show consistent sub-50ms processing times on standard servers—even with full machine-learning and Bayes filters enabled. This kind of performance is why Rspamd is chosen by large-scale email providers and cloud mail providers such as FastMail and Yandex.

Why speed matters in email processing

Latency beyond 100ms can impact delivery timing, especially in real-time sending scenarios. Delays in spam detection can lead to queue buildup, higher bounce rates, and diminished deliverability. You might not notice a single 150ms delay, but over thousands of messages, that accumulates into significant slowness.

MailTester’s real-time verification API (https://mailtester.com/api-email-checker/) can help you test email quality before sending—ensuring your list is clean and reducing the burden on your spam filtering engine. A faster, more accurate filter is only one part of a healthy email infrastructure. A clean list is another.

For teams evaluating filtering tools, the performance difference is measurable: SpamAssassin is flexible but slow; Rspamd is fast and scalable. If you’re aiming for 100ms or less, and you process more than a few hundred emails per minute, Rspamd is the only practical choice. For deeper insight into email infrastructure design, reference the RFC 5216 standards on message processing. The industry trend has long moved toward faster, distributed systems.

What impacts real-world scanning speed beyond the scanner itself?

Scanning speed isn't just about the filter engine—it’s shaped by DNS lookups, database performance, and your server’s hardware. Even a fast scanner like Rspamd can stall if DNS queries to RBLs timeout or if sender reputation data isn’t cached. The real bottleneck often lies outside the software itself.

DNS lookups and RBL queries can dominate processing time

When a mail server checks against a Real-time Blackhole List (RBL), each DNS query adds delay—especially if the DNS resolver is slow or overloaded. A single RBL lookup can take 50ms or more, easily pushing total scan time over 100ms, even if the core filter runs in microseconds. This is a common pitfall in high-volume environments, where the scan engine’s efficiency is masked by network overhead.

Use tools like MxToolbox to measure DNS response times and identify slow resolvers. If your mail server is making 10+ RBL queries per message, DNS latency becomes a real performance limiter. This is especially true when using multiple RBLs, which is standard practice in enterprise setups.

Database performance and system-level constraints

Lookups against sender reputation databases or past engagement records depend heavily on how fast data can be read from disk or memory. If these databases aren’t cached, or if your storage has high I/O latency, they can drag down scan speed regardless of how fast the filter engine is.

Even with a CPU-optimized engine like Rspamd, performance degrades on older hardware with slow SSDs or insufficient RAM. You can’t run an efficient filter on a system that spends most of its time waiting for disk I/O. Prioritize memory allocation and use SSDs with low latency—this helps more than choosing between SpamAssassin and Rspamd in some cases.

Let’s be clear: you don’t verify email lists with an API just to send them into a system that drops them due to latency. That’s why testing your actual email delivery path matters. Use inbox placement testing to confirm mail reaches the inbox—and how long it takes—to identify if delay stems from filtering, server load, or transport.

How does MailTester simulate real-time email verification speed?

You can verify email addresses in under 100ms per check using MailTester’s live SMTP stack, which mimics the speed of modern spam scanning systems like SpamAssassin and Rspamd. This real-time performance lets you test list quality at scale, avoiding bounces and delays from strict filtering before sending.

Live SMTP stack, real-world speed

MailTester doesn’t rely on heuristics or cached data. Instead, we use an actual SMTP session for each address, connecting directly to the recipient’s mail server. This process mirrors how spam filters evaluate incoming messages in production—checking MX records, accepting mail, and verifying the existence of the mailbox in real time.

Each verification round-trip completes in less than 100 milliseconds, aligning with the performance required by modern senders who need to verify tens of thousands of addresses rapidly—whether during onboarding, list cleaning, or campaign prep.

Why speed matters for deliverability

When you send to an address that triggers a delay—say, due to Greylisting, rate limiting, or a catch-all response—you risk damaging sender reputation, especially at scale. MailTester identifies these risk signals early: a result of “risky” or “catch-all” means the address isn’t guaranteed to receive mail, and may cause a timeout or reject.

Inbox placement testing shows how likely a message will arrive in a user’s primary inbox, including delays or filtering—helping you spot issues before your message even leaves your server.

For real-time integrations, MailTester’s API delivers results under 100ms per check, making it suitable for high-volume environments like e-commerce checkout flows or user registration systems. You can integrate it with platforms like Mailchimp, HubSpot, or Klaviyo to validate emails instantly—just like a spam scanner would.

SpamAssassin and Rspamd are designed to scan inbound messages efficiently, often under 100ms per message. By matching that speed, MailTester doesn’t just verify addresses—it simulates the real-world conditions under which deliverability is decided. This level of precision is essential when even a 1-second delay can lead to a message being treated as suspicious or blocked.

For a deeper look at how email scanning systems work, RFC 5321 (SMTP) and RFC 5322 (email format) provide the foundation. For industry context, Spamhaus offers insights into how filtering systems evaluate senders and content.

Can you use MailTester to test deliverability before sending?

You can use MailTester’s inbox-placement test to see how your emails will be received by real-world filters like Rspamd and SpamAssassin before sending. It evaluates headers, content, sender reputation, and known filtering behaviors across actual email infrastructure—so you know if your message lands in the inbox, gets flagged as spam, or is blocked.

Real-world testing, not just technical compliance

Many tools check for basic syntax or SPF/DKIM alignment, but MailTester goes further. It simulates how modern systems like Rspamd actually respond to your message content—checking things like word patterns, link reputation, and email structure—not just whether your DNS records are properly configured. This is how real inbox placement decisions are made.

For example, if your email contains a phrase commonly associated with spam (like “free money” or “act now”), or if it uses a domain flagged by Spamhaus or similar blacklists, MailTester will surface that risk—just like actual filters. This isn’t hypothetical; it’s built on live data from the same systems that influence deliverability on platforms like Gmail, Outlook, and Yahoo.

Let’s say you're sending a transactional email. You want to make sure it doesn’t get caught in a spam trap simply because of how it’s structured. Using MailTester’s inbox-placement test gives you a real-time preview of how a message would fare across modern email infrastructure—including systems designed to block spam at scale (like Rspamd, which runs on strict performance thresholds under 100ms).

How it works: from test to send

Start with MailTester’s inbox placement tester—upload a sample message, and it runs against a representative set of modern filtering engines. You’ll get a detailed report showing whether your message is likely to reach the inbox, be moved to spam, or be rejected outright.

This isn’t a one-time check. Use it as a guardrail in your workflow. Validate every batch before sending, especially during campaigns with high volume or sensitive content. You can also integrate it into your existing stack—MailTester works with Mailchimp, HubSpot, Klaviyo, and SendGrid via built-in integrations—so you don’t need to leave your tools to test deliverability.

For individual addresses, use the email checker to validate before sending. For larger lists, run bulk verification with the email list verifier, which includes deliverability risk flags alongside validity checks.

Testing before sending reduces wasted sends, protects sender reputation, and improves inbox placement—because you’re not guessing how filters will react. You’re seeing real behavior, powered by the same systems that protect inboxes today.

How does spam scoring influence deliverability outcomes?

High spam scores from tools like SpamAssassin or Rspamd don’t just trigger filters—they can result in outright rejection or delivery to spam folders, directly impacting inbox placement and sender reputation. Even messages with moderate scores may face delays or throttling under high server load, which over time erodes sender trust with major inbox providers.

Spam scores are not just warnings—they are gatekeepers

SpamAssassin and Rspamd evaluate inbound mail using hundreds of rules that flag suspicious content, missing or invalid headers, poor authentication (like missing SPF, DKIM, or DMARC), and known abusive patterns. A single high-scoring rule—like an unverified sender domain or a link to a known malicious domain—can push a legitimate email into quarantine or outright rejection.

Even if a message avoids a hard bounce, a score above the threshold set by a receiving mail server often triggers filtering. The result? Your email lands in spam, not the inbox. This is especially critical when sending at scale: a single misconfigured campaign can trigger pattern-based blacklisting or reputation penalties.

Performance matters: slow scans affect real sender behavior

While SpamAssassin and Rspamd are highly effective at identifying spam, their scanning speed under load can impact deliverability. Systems that take longer than 100ms per email to process may delay acceptance, especially during peak traffic. Delayed delivery signals poor infrastructure to inbox providers, who correlate low delivery times with reliability—and low reputation.

Even if your content passes every spam rule, a slow validation process can cause the receiving server to impose rate limits, queue your messages, or treat your domain as a poor sender. This is why real-time scanning performance is as important as accuracy. You can’t rely on tools that are accurate but too slow under pressure.

Using a service like MailTester’s email checker helps you catch invalid or risky addresses before they hit your sender stack—preventing spam traps, disposable emails, and other red flags that trigger high scores. It also reduces the load on your outbound infrastructure by validating addresses early.

For deeper insights, you can run real inbox placement tests via MailTester’s inbox tester to see how your messages perform across major providers. This gives you a clear signal of whether your scanning stack is letting you through, or getting you blocked.

What are the real trade-offs between SpamAssassin and Rspamd?

You're choosing between legacy depth and modern speed. SpamAssassin offers granular control with thousands of rules, but its monolithic design and reliance on Perl make it slow—often exceeding 100ms per email under load. Rspamd, built from the ground up for performance, uses Lua for scripting and runs in a single-threaded, event-driven architecture that handles thousands of messages per second with consistent sub-100ms response times, making it better suited for cloud-scale environments. While SpamAssassin has deep community roots and extensive documentation, Rspamd’s modular design and active development mean it’s now preferred in new mail infrastructure.

Speed and scalability: why performance matters

SpamAssassin’s rule engine evaluates every message through a chain of filters, each adding latency. In high-volume systems, this stacking effect can push processing time well past the 100ms threshold that modern delivery systems expect. Rspamd, by contrast, uses a real-time scoring model with lightweight, composable components. It’s designed with concurrency in mind—each check runs in parallel, and results are aggregated efficiently. This architecture enables consistent throughput, even during spam storms or sudden traffic spikes.

MailTester’s inbox placement testing helps confirm whether your message reaches the inbox before any scanning layer even sees it. If your scanning system is slow, even a perfectly clean email might be delayed or dropped by the receiving server’s queue. Testing delivery before sending helps catch these issues early. Test inbox placement across real inboxes with real mail clients to validate your end-to-end flow.

Customization vs. maintainability

SpamAssassin’s strength lies in its rule set—more than 4,000 rules cover everything from header manipulation to Bayesian word probabilities. But maintaining this system across multiple servers is complex. Updates to one rule can conflict with another, leading to unpredictable scoring. Rspamd’s approach is different: it favors modularity and configuration via Lua scripts, which are easier to version, test, and scale. This doesn’t mean less control—it means better control, with fewer side effects and clear debug logging.

While SpamAssassin still powers many legacy setups and is widely supported in older distributions (like Debian, CentOS, or cPanel), newer platforms are adopting Rspamd as their default. Many modern MTAs, including Exim and Dovecot, now include native Rspamd integration. The SPF specification (RFC 7328) highlights how sender authentication impacts filtering—Rspamd handles these checks efficiently, reducing dependency on slower, layered systems.

How to choose the right scanner for your email infrastructure?

You should pick Rspamd over SpamAssassin if you're running a high-volume or real-time email system where processing time must stay under 100ms. SpamAssassin's rule-heavy architecture often exceeds that threshold under load, while Rspamd is optimized for speed using modern, efficient hashing and clustering. Validate your choice with tools like MailTester to assess list quality and simulate how your content will be filtered.

Evaluate your core requirements

  • Measure your sending volume and peak throughput. If you send over 10,000 emails per minute, even minor delays add up quickly.
  • Define your acceptable processing latency. For real-time delivery, anything above 100ms starts to impact performance, especially at scale.
  • Check your infrastructure's CPU and memory profiles. SpamAssassin can be CPU-intensive; Rspamd is designed to reduce resource strain during high load.
  • Use SMTP RFC 5321 and RFC 5322 as baseline references when evaluating how scanners handle standard email formats and headers.

Test your assumptions with real data

  • Use MailTester’s inbox placement testing to see how different scanners might treat your actual email content under real-world conditions.
  • Run bulk verification on your list using MailTester’s bulk email checker to clean out invalid or risky addresses before sending.
  • Test individual addresses with MailTester’s email verifier to catch issues early and reduce the load on your scanner.
  • For API-driven workflows, integrate the MailTester verification API to validate addresses in real time, avoiding scanning over bad data.
  • Simulate delivery scenarios to gauge how your mail performs across different filters and threshold settings — including those used by SpamAssassin and Rspamd.

How do you measure email verification and deliverability speed accurately?

You measure email verification speed by running real SMTP checks that time every stage—connection, response, and processing—down to the millisecond. Tools that return verdicts (valid, invalid, risky, catch-all) in under 100ms, like MailTester, let you catch slow filters, bad addresses, or risky senders before they hit your inbox. This level of precision isn’t about cutting corners—it’s about measuring the actual performance of email validation systems under real-world load.

Why raw speed matters in email verification

Speed isn’t just about performance; it’s about reliability. A verification that takes 200ms isn’t unusable, but it becomes problematic when scaling to thousands of emails. If you’re relying on real-time validation for sending workflows, every extra 10ms adds up. You want to know if a filter is sluggish—not just that it flagged something. That’s why measuring the full SMTP exchange chain, from TCP handshake to final response, gives you the full picture.

MailTester performs full real-time SMTP verification and returns results—with timestamps and clear verdicts—within 50–100ms on average. This speed is consistent across bulk list verification, API calls, and inbox placement tests, which means you’re not just checking validity; you’re stress-testing your entire delivery stack. The time breakdown you get reveals where delays occur: is it the DNS lookup, the SMTP handshake, or the server response?

How to trust what you measure

Not every tool measures the same way. Some claim fast results but skip parts of the SMTP handshake or rely on heuristics. The only way to verify an email is through actual SMTP communication—or a proxy that simulates it with known accuracy. Tools that only test syntax or domain presence miss bounces, greylisting delays, and role-based account patterns that only real SMTP exposure reveals.

When you verify at scale, especially for campaigns with high engagement expectations, you need to know whether a domain is genuinely deliverable, not just syntactically valid. Real SMTP checks catch issues like catch-all configurations, temporary delivery failures, and blocked sender reputations—things that no syntax or reputation-only scanner can detect reliably.

For real-time use, the verification API at MailTester ensures you can run checks in under 100ms consistently. Whether you’re filtering user sign-ups, cleaning up a 100k list, or testing inbox placement, the precision of the timing data helps you isolate which filters are slowing down delivery—so you can adjust your sending strategy before you send.

Learn how real-time SMTP verification works with the MailTester verification API, or test your list health with bulk email validation. The speed you measure today will shape your deliverability results tomorrow.

What’s the bottom line for email deliverability in 2026?

Speed, accuracy, and consistency in email filtering are no longer optional. Modern inbox providers and anti-spam systems process messages in milliseconds. Delays or inaccuracies in scanning directly impact inbox placement.

Rspamd consistently meets the 100ms threshold at scale, making it the preferred choice for high-throughput environments. SpamAssassin, while reliable, often struggles to maintain consistent performance under load, leading to bottlenecks.

Verification and deliverability testing are essential to ensure your messages pass through these filters without issue. MailTester provides measurable results — from real-time inbox placement tests to bulk list validation — so you know your emails will land where they’re meant to, every time.

Sources

Keep reading

Ready to put this into practice? MailTester verifies emails with 98.9% accuracy — start with 100 free verifications.

Frequently asked questions

Is SpamAssassin still viable for modern email systems?

Yes, but only in low-volume or legacy systems. Its performance degrades under load, making it unsuitable for real-time, high-throughput infrastructure.

Does Rspamd handle all spam and malware threats?

It covers the vast majority of threats through configurable rules, machine learning, and real-time updates, but no single tool can catch every attack.

Can email verification tools like MailTester replace spam scanning?

No — verification checks addresses and delivery path viability, but does not replace content-based spam filtering. Both are needed.

How does MailTester achieve 98.9% accuracy in email verification?

It uses real SMTP connections, checks MX records, validates syntax, and applies pattern-based logic to detect role, disposable, and catch-all emails.

Are there trade-offs in using faster spam scanners like Rspamd?

Yes — reduced rule depth and customization can lead to missed edge-case spam. This requires careful configuration and ongoing monitoring.

What happens when a message exceeds 100ms in filtering?

It may be delayed or dropped, especially under strict policies. This affects sender reputation and inbox placement.

Can I test deliverability with MailTester before sending?

Yes — the inbox-placement test simulates real-time delivery conditions using actual sender reputation metrics and filter behavior.

How many free verifications does MailTester offer?

You get 100 free verifications to start, with no expiry on purchased credits.

Does MailTester work with SendGrid and Mailchimp?

Yes — it integrates with SendGrid, Mailchimp, HubSpot, and Klaviyo to verify lists and improve deliverability before sending.

What’s the difference between a catch-all and a risky email?

A catch-all accepts all addresses, but may not be user-facing. A risky address has high bounce or spam potential based on domain and pattern analysis.

Can I verify bulk lists with MailTester?

Yes — the bulk verification feature checks thousands of addresses quickly, filtering out invalid, disposable, and role accounts.

Is real-time verification faster than traditional methods?

Yes — real-time verification using live SMTP connections confirms delivery viability within 50–100ms, reducing guesswork and improving list hygiene.