---
title: "Auto-Post New Blog Articles Across Channels with n8n"
description: "Build an n8n workflow that detects new blog posts, uses an AI node to tailor copy per platform, and cross-posts everywhere — no separate LLM key needed."
canonical: https://agentroost.app/en/blog/auto-post-blog-articles-channels-n8n
date: 2026-06-07T12:00:00Z
---

[Canonical URL](https://agentroost.app/en/blog/auto-post-blog-articles-channels-n8n)

Every time you publish a new article, the same manual loop starts: copy the title, craft a tweet that fits 280 characters, write a different intro for LinkedIn, paste a short blurb into Slack, maybe schedule a Mastodon post. It takes 15–20 minutes and it is the kind of repetitive work that quietly eats your mornings.

This guide shows you how to wire an n8n workflow that handles the whole loop automatically — detect the new post, let an AI node rewrite the blurb for each platform's tone and length, then publish. One workflow, every channel, zero manual steps after setup.

## The Architecture in One Sentence

Poll your blog's RSS feed on a schedule → deduplicate (skip already-seen posts) → call the AI/LLM node once per channel to generate tailored copy → post to Twitter/X, LinkedIn, and Slack in parallel.

## Nodes You Will Use

| Node | Purpose |
|---|---|
| **Schedule Trigger** | Fire the workflow every 15–30 minutes |
| **HTTP Request** | Fetch your RSS/Atom feed as XML |
| **XML** | Parse the feed into JSON items |
| **IF** | Skip GUIDs already stored in static data |
| **Static Data** (via Code node) | Remember which GUIDs have been posted |
| **AI / LLM node** (OpenAI / Anthropic compatible) | Generate per-channel copy |
| **Twitter / X node** | Post the tweet |
| **LinkedIn node** | Publish the company or personal update |
| **Slack node** | Send a message to a channel |

## Step-by-Step Build

### 1. Trigger on a schedule

Add a **Schedule Trigger** node. Set interval to **Every 15 minutes** (or 30 if your blog publishes infrequently). This keeps the workflow always watching without hammering your server.

### 2. Fetch the RSS feed

Add an **HTTP Request** node.

- Method: `GET`  
- URL: `https://yourblog.com/rss.xml` (or your Atom feed URL)  
- Response format: `Text`

### 3. Parse the XML

Add an **XML** node connected to HTTP Request.

- Source: `{{ $json.data }}`  
- Output key: `feed`

After this node each item in `feed.rss.channel.item` is a JSON object with fields like `title`, `link`, `pubDate`, and `guid`.

### 4. Deduplicate with a Code node + IF

The tricky part: your workflow runs every 15 minutes, but a post sits in the feed for days. Without deduplication you will re-post it hundreds of times.

Add a **Code** node (Run Once for All Items mode):

```js
const seen = $getWorkflowStaticData('global');
if (!seen.guids) seen.guids = [];

const items = $input.all();
const newItems = items.filter(item => {
  const guid = item.json.guid?.['_'] ?? item.json.guid ?? item.json.link;
  return !seen.guids.includes(guid);
});

// mark as seen immediately (even before posting, to avoid double-post on retry)
newItems.forEach(item => {
  const guid = item.json.guid?.['_'] ?? item.json.guid ?? item.json.link;
  seen.guids.push(guid);
  if (seen.guids.length > 500) seen.guids.shift(); // rolling window
});

return newItems;
```

Connect this to an **IF** node that checks `{{ $json }}` is not empty (i.e., there are actually new items). The `false` branch ends the execution silently.

### 5. Generate per-channel copy with the AI node

Add a **Basic LLM Chain** (or **AI Agent**) node for **each channel**. You can branch with a **Split In Batches** or just run three separate AI nodes in sequence.

**Twitter/X prompt** (system message):
```
You are a copywriter. Write a tweet (max 240 characters, no hashtag spam) 
that teases the key insight of this article and ends with the URL.
Article title: {{ $json.title }}
Article URL: {{ $json.link }}
Article description: {{ $json.description }}
```

**LinkedIn prompt** (system message):
```
Write a 3-sentence LinkedIn post for this article. 
Open with a specific hook (a question or a surprising fact), 
summarize the key takeaway in one sentence, 
and close with a call to read the full piece.
Article title: {{ $json.title }}
Article URL: {{ $json.link }}
Article description: {{ $json.description }}
```

**Slack prompt** (system message):
```
Write a short Slack message announcing this article to a technical team.
One sentence summary + the URL. Casual tone.
Article title: {{ $json.title }}
Article URL: {{ $json.link }}
```

Each AI node returns `{{ $json.text }}` (or `{{ $json.output }}` depending on the node version) — that is the ready-to-post copy.

### 6. Post to each channel

- **Twitter/X node**: Action → *Create a Tweet*, Text → `{{ $json.text }}`
- **LinkedIn node**: Action → *Create a Share*, Text → `{{ $json.text }}`, visibility `PUBLIC`
- **Slack node**: Action → *Send a Message*, Channel → `#content` or `#marketing`, Text → `{{ $json.text }}`

Wire all three in parallel after their respective AI nodes. If one channel fails (e.g., a Slack API blip), the others still succeed — n8n's branching keeps them independent.

### 7. Error handling (optional but recommended)

Add an **Error Trigger** node at the workflow level and connect it to a Slack node pointing to a `#errors` channel. You will know immediately if posting breaks without having to check logs manually.

## Tips and Pitfalls

**"Why did my post appear twice?"**  
The static data write in the Code node happens before posting on purpose. If you write it after and the workflow crashes mid-run, n8n retries from scratch and posts a duplicate. Writing the GUID first makes the workflow idempotent.

**"LinkedIn keeps failing auth."**  
LinkedIn OAuth tokens expire after 60 days. Set a calendar reminder to re-authenticate the credential before the deadline, or check n8n's credential expiry warnings.

**"The tweet is over 280 characters."**  
Add a temperature of `0.3` to the Twitter AI node and include `"IMPORTANT: stay under 240 characters"` at the top of the system prompt. Lower temperature means less creative risk-taking and more reliable length discipline.

**Feed with no description field**  
Some minimal RSS feeds omit `<description>`. Substitute `{{ $json.title }}` alone in the prompt and ask the AI to infer context from the title — it usually does a reasonable job.

## Run It on AgentRoost — No DevOps Required

The workflow above runs 24/7 on your own n8n instance. Getting that instance running is where most people get stuck: Docker Compose, SSL certs, domain DNS, reverse proxy, environment variables, updates. It is a weekend of setup and an ongoing maintenance surface.

**On AgentRoost, your n8n instance is yours from minute one — you own the login, the workflows, and the data — and the infrastructure is already running.** Here is the actual path:

1. Go to [AgentRoost](/en/agents/n8n) and sign up (email/password, Google, Microsoft, or Discord).
2. Choose the **n8n** framework, give your instance a name.
3. Your private n8n editor opens at `https://<your-id>.agentroost.app` — your login, no one else's.
4. Import the workflow above or build it node by node.
5. **The AI/LLM node already has credits wired in.** No OpenAI API key to generate, no billing account to configure on a separate service. The AI nodes just work.

Starting at **$19.99/mo all-in**, that covers the compute, the SSL, the domain routing, and the included AI credits that power the LLM nodes. There is no separate API bill to worry about when your cross-posting workflow runs every 15 minutes and calls the AI three times per new post. [Compare plans](/en/pricing) to see which tier fits your publishing volume, and there is a 14-day money-back guarantee if it is not the right fit.

> Every major competitor — n8n Cloud, Elestio, Sliplane — is bring-your-own-API-key. You pay for the hosting AND for OpenAI/Anthropic separately. On AgentRoost the AI credits are bundled. The AI nodes in this exact workflow work out of the box.

## What to Automate Next

Once this workflow is running, the same RSS → AI → publish pattern extends naturally:

- **Newsletter digest**: collect a week of posts, summarize them with the AI node, send via the Mailchimp or Brevo node.
- **SEO internal linking**: when a new post is detected, search your existing content index (HTTP Request to your CMS API) and have the AI suggest internal links to add.
- **Repurposing queue**: write a "thread" version of the article for X (7 tweets), store each tweet as a separate item, and schedule them over 7 days with a Wait node.

The workflow you built here is the foundation. Each extension adds one or two nodes — no new infrastructure.