Feedletter: Turn an RSS Feed or Markdown Folder into a Newsletter

You publish. New posts pile up in a feed or a content/ folder. And the newsletter that was supposed to go out "every couple of weeks" keeps slipping, because turning a list of posts into a clean, tested email is more fiddly than it should be.

Feedletter closes that gap. It is a small open-source tool that reads an RSS/Atom feed or a local Markdown directory, turns recent items into an email-safe issue, and sends it through SMTPfast. There is a command line for automation and a browser studio for the times you want to hand-pick what goes out.

It is MIT licensed and free. You only need an SMTPfast API key at the moment you actually want to send.

What it does

Feedletter takes content you already have and produces a newsletter from it:

• Two sources. Point it at an RSS/Atom feed or a local Markdown/MDX directory. It selects recent items and pulls out titles, summaries, links, and cover images.
• Real email output. It writes email-safe HTML, a plain-text version, and a structured JSON file, so the result renders in Gmail, Apple Mail, and Outlook rather than only in a browser.
• Curation, not just generation. The studio lets you include or exclude items, reorder them, and edit titles and summaries inline before anything is sent.
• No double sends. A small SQLite history remembers which posts already went out, so the same article is never included in two issues.
• Optional AI polish. If you want it, Feedletter can draft the subject, preheader, and intro with any OpenAI-compatible API, or hand the job to a local agent command like Claude Code or Codex.

The studio

The fastest way to get a feel for it is the studio, a local browser tool. Start it and open the URL it prints:

feedletter studio
# or preload a source:
feedletter studio --content ./content/blog --base-url https://example.com

You land on a filled-in draft, not a blank form: the subject, preheader, and intro are written for you the moment items load. From there you curate the list with checkboxes, drag items to reorder, and edit any title or summary in place. A live preview shows the exact email as you work, in both its HTML and plain-text forms.

When the issue looks right, open the send drawer, paste an SMTPfast API key, set a verified From address, and add recipients. Feedletter checks that the sending domain is verified before it lets you send, and each message carries its own {{unsubscribe_url}} so recipients can opt out.

Getting started

Feedletter runs on Node 20+. Clone the repo, install, and build:

git clone https://github.com/smtpfast/feedletter
cd feedletter
npm install
npm run build
npm link   # optional: puts the `feedletter` command on your PATH

If you would rather not build, npm run dev -- studio runs the same thing straight from source.

Build an issue from an RSS feed:

feedletter build \
  --rss https://example.com/feed.xml \
  --title "This week from the blog" \
  --out dist/newsletter

Or from a Markdown content directory, which is handy if your site is a static generator:

feedletter build \
  --content ./content/blog \
  --base-url https://example.com \
  --title "Latest posts" \
  --limit 5 \
  --out dist/newsletter

That writes the HTML, text, and JSON into dist/newsletter. You can preview it locally, open it in the studio, or send it.

Sending with SMTPfast

For a non-interactive send, the send command takes a built directory and delivers it. This is the piece you would run from CI:

feedletter send \
  --dir dist/newsletter \
  --from "Your Team <[email protected]>" \
  --to-file subscribers.txt

Sending is where SMTPfast comes in. Feedletter posts each message through the SMTPfast API, so you get a verified sending domain, DKIM and SPF and DMARC handled, per-recipient unsubscribe links, and suppression of anyone who has bounced or unsubscribed. The API key can come from --api-key or the SMTPFAST_API_KEY environment variable, so it never has to live in your config.

Automate it with a GitHub Action

The repo ships an example workflow that builds and sends on a schedule and commits the history file back, so a post is never sent twice even across runs:

# .github/workflows/newsletter.yml (abridged)
on:
  schedule:
    - cron: "0 15 * * 1"   # Mondays
jobs:
  send:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm install && npm run build
      - run: feedletter build --rss https://example.com/feed.xml --out dist/newsletter
      - run: feedletter send --dir dist/newsletter --from "News <[email protected]>" --to-file subscribers.txt
        env:
          SMTPFAST_API_KEY: ${{ secrets.SMTPFAST_API_KEY }}

Set the schedule, drop your key in a repository secret, and the digest goes out on its own.

Sending to a big list

For a small list, one message per recipient through the API is fine. For a large audience you want batching, tracking, and analytics. In that case the studio hands off cleanly: it copies the issue HTML and links you to a SMTPfast broadcast, where you can send to a whole segment, schedule it, and watch open and click rates. Feedletter builds the issue; broadcasts handle the scale.

Why we open-sourced it

Feedletter is deliberately free and unbranded. It solves a real chore for anyone who publishes content, and when you are ready to actually send, SMTPfast is the fast path with a verified domain and honest deliverability. The tool works on its own; the sending is where we can help.

The source is on GitHub under MIT. Clone it, read it, open an issue, or send a pull request. If you do not have an SMTPfast account yet, create one free and send your first newsletter in a few minutes.