Generating and sending an automatic newsletter from an RSS feed with AI in n8n

Many teams that produce content or run a watch process know a regular newsletter builds loyalty better than an RSS feed nobody checks — and know just as well why they don't send one: picking the right articles, summarizing them and composing the email eats a good morning every week, time few teams can commit to consistently. A study of the content of nine major US newsroom newsletters, Seely & Spillman (2021), Email Newsletters: An Analysis of Content From Nine Top News Organizations, published in Electronic News (Google Scholar), found that newsletters that work rely mainly on two techniques: summarization (condensing an article's essence) and a short editorial comment that puts the information in context — exactly what a well-scoped LLM can produce from an RSS feed excerpt. This guide builds the full pipeline in n8n: multi-source collection, AI selection and summarization, HTML layout, and sending via Brevo.

The five-stage architecture

The pipeline reuses the same backbone as a classic RSS watch setup, with two extra stages at the output end:

1. Collection — read the RSS feeds from your reference sources.
2. Deduplication and filtering — keep only what's new and relevant to your audience.
3. AI selection and summarization — an LLM ranks the remaining articles and writes a short editorial summary for the best ones.
4. Composition — assemble the selected blocks into a clean HTML email.
5. Sending — trigger the campaign via Brevo, on a fixed cadence (weekly in most cases).

Stage 1 — Collecting several RSS feeds

A Schedule Trigger (see our guide on the Schedule Trigger and timezones) starts the workflow, for example every Monday at 6 am. It walks a list of feeds — stored in an n8n Data Table or a Google Sheet rather than hardcoded in the workflow — through a Loop Over Items that calls an RSS Feed Read node once per source. Enable "Continue On Fail" on that node: one feed being temporarily down shouldn't break the whole week's newsletter.

Stage 2 — Deduplicating and filtering before any AI call

Two nodes protect the rest of the pipeline:

• Remove Duplicates, in "Remove Items Processed in Previous Executions" mode with the article's link as the key, guarantees that an article already sent in a previous edition never reappears. The full mechanics are covered in our guide to the Remove Duplicates node.
• Filter drops anything clearly outside your editorial line (excluded keywords, publish date too old). This mechanical, free filtering directly shrinks the volume that reaches the LLM in the next stage — the pipeline's real cost lever.

Stage 3 — Selecting and summarizing with an LLM

This is where the newsletter takes shape. A Basic LLM Chain node (see the difference with the AI Agent node if you're unsure which one to use) receives the filtered article list — title and excerpt only, never full content invented or padded out — with a strict instruction set:

• rank the articles by relevance to the target audience;
• keep only the top 5 to 8;
• write, for each one, a two-sentence-maximum summary based exclusively on the text provided, in a sober editorial tone rather than a promotional one;
• never add a fact, figure or quote absent from the source excerpt.

A Structured Output Parser (detailed in our dedicated guide) forces the response into a strict JSON schema — title, summary, link, category — so the composition stage never has to parse free text. If your feeds return long articles, a Summarize node upstream can pre-condense the body before passing it to the selection LLM, cutting token cost further.

Stage 4 — Composing the HTML email

A Code node turns the structured JSON array into HTML: one block per article (title as a clickable link, summary, category badge), framed by a fixed header and footer containing the unsubscribe link — mandatory, and generated automatically by Brevo if you go through its campaigns rather than a raw transactional send. Keep this template simple: single column, few images, text readable without client-side image loading — which also limits the risk of landing in spam.

Before sending, an IF node checks that the number of selected articles clears a minimum threshold (3, for instance): below it, the workflow notifies the team on Slack instead of sending a thin edition.

Stage 5 — Sending via Brevo

The native n8n Brevo node covers contacts and transactional sending, but not marketing campaign creation: for that, an HTTP Request node calls Brevo's POST /v3/emailCampaigns API endpoint with the same credential (api-key header), passing the subject, sender, recipient list and the HTML composed in the previous stage. Two options from there: trigger an immediate send via POST /v3/emailCampaigns/{id}/sendNow, or leave the campaign as a draft for a final human review in the Brevo interface before it goes out — recommended for the first editions, until you trust the pipeline.

Hardening it before production

• Human review at the start. Instead of calling the send endpoint directly, post the HTML draft to Slack or send it to a single test address, with a Wait node holding for approval before triggering the real send — the same human-approval pattern described for other sensitive automations.
• Traceability. Log every sent edition (date, selected articles, recipient count) in a Supabase table: useful for measuring what works and for quickly looking up what went out if a subscriber asks.
• Controlled cost. With an economical model (gpt-4o-mini or equivalent) and mechanical filtering upstream, selecting and drafting a weekly edition of 5 to 8 articles typically costs a few cents in API calls.
• Non-blocking errors. Attach an error workflow to the whole pipeline: a downed RSS feed or a failed Brevo call should alert the team, never silently skip the week's newsletter.

Going further with a FlowKit pack

The collect → AI scoring → digest pattern is already the one behind the daily Slack digest workflow from the Inbox AI Pack (€79), which sorts and summarizes your emails with the same structured-scoring logic — directly adaptable if you'd rather deliver your watch internally before turning it into an external newsletter. Both pipelines share the same n8n backbone: LLM Chain, Structured Output Parser, Supabase queue.

Launch checklist

• RSS feed list externalized (Data Table or Sheet), with Continue On Fail enabled.
• Remove Duplicates in "Previous Executions" mode on the article link.
• Strict selection prompt: summarize only the text provided, never invent.
• Structured Output Parser for reliable JSON out of the LLM.
• Minimum article threshold before sending, with a Slack alert below it.
• Initial phase with human review before full automatic sending.
• Supabase logging of every edition sent.

A newsletter automated this way doesn't replace real editorial judgment — it simply makes it sustainable over time: the LLM handles the sorting and the first draft, a human keeps final say on approval until trust in the pipeline is established. It's the same logic FlowKit's packs apply to emails or support tickets: automate the repetitive sorting, keep the human on the decision that matters.