RSS to email: the no-AI baseline

Before you wire an LLM into your reading pipeline, it is worth knowing the baseline: plain RSS-to-email has worked for two decades, costs nothing to almost nothing, and has zero moving parts that can hallucinate. This guide covers the honest options - hosted services, self-hosted rss2email, the reverse trick for email-only newsletters, and a minimal Python script - and ends with a clear-eyed take on when no-AI is genuinely enough.

Option 1: Hosted services (zero maintenance)

If you want feeds in your inbox by tonight with no server and no code, use a hosted service. The trade-off is the usual one: someone else's infrastructure, someone else's pricing changes, and your reading list on someone else's server.

• Blogtrottr - the old reliable. Paste a feed URL and your email address, pick a delivery schedule (realtime up to daily digest), done. Free tier with ads in the emails; paid tiers remove them. No account needed to start.
• Feedrabbit - cleaner and more modern. Subscribe to feeds, get each post as a nicely formatted email. Free for a handful of feeds, paid (a few dollars per month) beyond that.
• Feedbin - a full RSS reader (paid, around 5 USD per month) that includes email delivery features and, usefully, gives you an email address for receiving newsletters into your reader, merging both directions in one tool.
• IFTTT and similar automation platforms can also do feed-to-email, but a dedicated service is less fragile for this specific job.

Option 2: The reverse direction - Kill the Newsletter

Half the interesting writing now ships as email-only newsletters with no public feed. Kill the Newsletter (kill-the-newsletter.com) inverts them: it generates a unique email address for each newsletter you subscribe with, and turns everything sent to that address into an Atom feed. Subscribe to that feed like any other, and your newsletters and blogs flow through one pipeline. It is free, open source, and can be self-hosted.

Privacy note for both directions: a hosted middleman sees everything that passes through it. For public blog feeds that is trivially fine; for paid or private newsletters, think before routing them through third-party converters.

Option 3: Self-hosted rss2email

rss2email is a Python tool that has been doing exactly this job since 2004: fetch feeds, remember what it has seen, email you new items. It runs anywhere Python runs, keeps state in a local JSON file, and sends through any SMTP server. This is the strongest self-hosted answer.

# Install (pipx keeps it isolated; pip install rss2email also works)
pipx install rss2email

# Create the config and add feeds
r2e new you@example.com
r2e add hn "https://hnrss.org/frontpage"
r2e add verge "https://www.theverge.com/rss/index.xml"

# List what you are subscribed to
r2e list

# Fetch and send new items (first run: mark everything as read
# instead of emailing the entire backlog)
r2e run --no-send
r2e run

By default rss2email tries to send via a local sendmail, which most machines no longer have. Point it at real SMTP in its config file instead.

[DEFAULT]
from = you@example.com
to = you@example.com
use-smtp = True
smtp-server = smtp.gmail.com
smtp-port = 587
smtp-ssl = False
smtp-username = you@gmail.com
smtp-password = your-app-password
email-protocol = smtp

# crontab -e : check feeds every 2 hours
0 */2 * * * /home/you/.local/bin/r2e run >> /home/you/r2e.log 2>&1

One caveat: the config file holds your SMTP password in plain text, so keep its permissions tight (chmod 600). And run r2e run --no-send once before the first real run, or rss2email will cheerfully email you every item currently in every feed.

Option 4: A minimal Python digest script

If rss2email is more machinery than you want, here is the whole idea in about 40 lines: fetch feeds, skip seen URLs, batch everything new into one plain email. No LLM, no summaries - titles and links, which is often all you need.

#!/usr/bin/env python3
"""Minimal RSS-to-email digest. No AI, no dependencies but feedparser."""

import os
import smtplib
from email.mime.text import MIMEText
from pathlib import Path

import feedparser

FEEDS = [
    "https://hnrss.org/frontpage",
    "https://www.theverge.com/rss/index.xml",
]
SEEN = Path(__file__).with_name("seen.txt")


def main() -> None:
    seen = set(SEEN.read_text().splitlines()) if SEEN.exists() else set()
    items = []
    for url in FEEDS:
        feed = feedparser.parse(url)
        source = feed.feed.get("title", url)
        for e in feed.entries:
            link = e.get("link", "")
            if link and link not in seen:
                items.append((source, e.get("title", "(no title)"), link))
                seen.add(link)

    if not items:
        return

    lines = [f"[{src}] {title}\n{link}\n" for src, title, link in items[:50]]
    msg = MIMEText("\n".join(lines))
    msg["Subject"] = f"Feed digest: {len(items)} new items"
    msg["From"] = os.environ["MAIL_FROM"]
    msg["To"] = os.environ["MAIL_TO"]

    with smtplib.SMTP(os.environ["SMTP_HOST"], 587, timeout=30) as s:
        s.starttls()
        s.login(os.environ["SMTP_USER"], os.environ["SMTP_PASS"])
        s.send_message(msg)

    SEEN.write_text("\n".join(sorted(seen)[-5000:]) + "\n")


if __name__ == "__main__":
    main()

Run it from cron once or twice a day with the SMTP variables set in the environment. This script is the seed of the AI versions in the sibling tutorials: add one function that passes the items through an LLM before the email step and you have converted this into an AI newsletter.

When no-AI is actually enough

The honest test is volume and signal. If your feeds produce under roughly 20 items a day and you already only follow sources you trust, summarization adds latency, cost and a new failure mode while saving you almost nothing - headlines are already summaries. Plain RSS-to-email also has properties the AI version cannot match: every word in the email was written by the original author, nothing is ever paraphrased wrong, and the pipeline has no API key to expire.

The LLM layer starts paying for itself in three situations: high volume (50+ items a day where triage is the real problem), cross-source synthesis (five outlets covering the same story that you want collapsed into one paragraph), and filtering by meaning rather than keyword (skip funding announcements unless the company works on batteries). If none of those describe your reading, save the money and the maintenance.

What this really costs

This is the cheapest corner of the whole newsletter-automation space, and the most durable: rss2email has outlived several generations of startups doing the same thing with more funding. The main cost is not money but inbox discipline - raw feeds deliver everything, and everything can be a lot.

A sensible path: start here, free and boring, and let real pain justify each upgrade. Most people who set up feed-to-email never need more. The ones who do will know exactly why, and the sibling tutorials cover that next step.