Publish Once, Distribute Everywhere: The n8n Content Pipeline

Writing the article is maybe 60% of the work. The other 40% is the tedious part: rewriting it four different ways, posting each version to a different platform, and remembering to stagger them so you don't blast everything at 9:04am like a bot.

That 40% is pure mechanism, which makes it exactly the kind of thing to hand to a machine. This is the pipeline I run on my own self-hosted n8n: my RSS feed is the trigger, an LLM writes the platform variants, and a queue posts them on a schedule. What follows is the real build, including the parts that cost money and the parts that break.

The Shape of It

The instinct is to build one workflow: RSS triggers, LLM rewrites, post everywhere, done. Don't. Build two.

The reason is durability. A single workflow that staggers posts with long Wait nodes holds execution state for hours, and anything that restarts n8n in that window loses the queue. Splitting it means a restart costs you nothing, retries are trivial, and you can inspect exactly what's pending before it goes out. It's twenty extra minutes of build for a pipeline that survives contact with reality.

Step 1: The RSS Trigger (and Why Your First Test Will Lie to You)

n8n's RSS Feed Read Trigger looks simple, and its actual behavior surprises almost everyone. I went and read the node source rather than the docs, because the docs don't explain the mechanism:

• The first poll returns zero items. The node stores a "last item date," and on first run it has none — so it uses "now" as the baseline and everything in your feed predates it. There's no first-run flood. The opposite risk applies: publish an article seconds before activating the workflow and it will never be picked up.
• Manual test execution bypasses polling entirely and just returns the newest feed item. So your test always works and tells you nothing about production behavior. This is the single biggest source of "it worked when I tested it" in this build.
• It keys on date, not GUID. If your CMS bumps pubDate when you fix a typo, the workflow re-fires and posts your article again.

That last one is the important one, and the fix is a node n8n already ships. Drop a Remove Duplicates node right after the trigger, set operation to "Remove Items Processed in Previous Executions," Keep Items Where = "Value Is New," and dedupe on the item GUID or link rather than the date. It keeps a 10,000-item history by default. This one node eliminates the entire class of duplicate-posting bugs that fill the n8n community forums.

Step 2: The Rewrite

Use a Basic LLM Chain node, not an AI Agent. Agents need at least one tool sub-node and add nondeterminism for no benefit here — this is a single transformation, not a task requiring judgment about which tool to reach for.

Attach a Structured Output Parser so you get one clean JSON object with a field per platform rather than prose you have to regex apart. Turn on "Require Specific Output Format" on the chain node to wire them together.

Here's the prompt I use. The platform constraints are baked in deliberately — they're not stylistic preferences, they're hard API limits that will fail your posts if violated:

Two things to notice. The X output is split into x_main and x_reply — that's not a style choice, it's a cost decision, and the next section explains why. And the Reddit body is written to stand alone, because dropping a bare link into a subreddit is the fastest route to a shadowban.

Step 3: The Platforms (What They Cost, What's Possible)

This is the section most tutorials skip, and it's the one that determines whether your pipeline is free or quietly expensive.

The X pricing thing, because it changes the design

X moved to pay-per-use pricing in February 2026 — no subscription tiers, you buy credits and they're deducted per call. Creating a post is $0.015. Creating a post containing a URL is $0.200.

That's a 13× penalty on exactly the thing content distribution does. Posting three articles a week costs about $2.60/month; daily costs around $6. Not ruinous, but worth knowing before your credit balance quietly drains. And be aware the workaround doesn't work: putting the link in a first reply is a second post, so it's another $0.20. The genuine options are eating the cost, or writing a linkless post that drives people to your profile — which is why the prompt above generates x_main with no URL in it.

The LinkedIn split

Posting to your personal profile is self-serve: enable "Share on LinkedIn" in the developer portal, grab the w_member_social scope, no app review. The limit is 150 requests per member per day, which you will never approach.

Posting to a company page requires the Community Management API, a formal app review, a registered legal entity, a verified business email, and for the standard tier, a high-resolution screen recording of your entire OAuth flow. For a solo operator this is not a realistic weekend project. Post as yourself.

Bluesky: free, but you have to build the post properly

Bluesky is the best-behaved platform on this list — free, no approval, and a budget of roughly 1,666 posts per hour that you will never hit. Two non-obvious client responsibilities though: URLs in post text are not clickable by default (you have to construct byte-range "facets"), and link preview cards are not auto-generated (you fetch the OG tags, upload the thumbnail as a blob, and build the embed object yourself).

Use the @muench-dev/n8n-nodes-bluesky community node and both problems disappear — it does automatic facet detection and builds website cards from Open Graph metadata. Community nodes require self-hosting, which for once is an advantage of the setup you already have.

Step 4: Staggering

Posting everything simultaneously is the clearest bot signal there is. Three ways to spread it out, in ascending order of how much I like them:

Wait nodes work, with one implementation detail worth knowing: under 65 seconds n8n keeps the execution in memory, and at 65+ seconds it offloads state to the database and frees the process. So always cross that threshold when staggering across hours.

HTTP Request batching is cleaner for the HTTP-based platforms — the node has Items per Batch and Batch Interval options built in. Set batch size 1 and interval 900000ms and you have 15-minute staggering with zero extra nodes.

The queue table is what I actually use, and it's the whole reason for the two-workflow split. Workflow A writes each variant with a publish_at value — say LinkedIn at +0, Bluesky at +25 minutes, X at +90, Mastodon at +2 hours. Workflow B wakes up every 15 minutes, grabs what's due, posts it, marks it done. Restart-proof, inspectable, and trivially retryable.

One scheduling gotcha: n8n's cron is six fields, not five — the first is seconds. Paste a standard crontab string and your schedule silently means something else. And self-hosted n8n defaults to America/New_York, so set GENERIC_TIMEZONE unless that's genuinely your timezone.

Step 5: The Newsletter Leg

If you're on beehiiv, the same pipeline can draft your newsletter. POST /v2/publications/:publicationId/posts with a bearer token creates a post from either structured blocks or raw HTML.

Three things that will cost you an afternoon otherwise. The Create Post endpoint requires the Max plan — subscriber management works on any tier, but programmatic posting doesn't. Since August 6th 2026 you must explicitly pass "status": "confirmed" to publish; omit it and you silently get a draft, which broke a lot of existing workflows. And body_content expects HTML, not markdown, so you need a conversion step.

Also: the endpoint returns 201 immediately but processing is asynchronous. Naive retry-on-failure logic can double-create posts. Check before you retry.

The Three Things That Will Break

What This Actually Buys You

Roughly forty minutes per article, and — more valuable — the consistency. The reason most people's distribution is bad isn't that they can't write a LinkedIn post; it's that after finishing a 2,000-word article, nobody feels like writing five more things. Automating it means the distribution happens on the days you don't feel like it, which is most days.

Build workflow A first and let it write to the queue without publishing anything for a week. Read what it produces. The LLM variants will be about 70% right at the start, and the prompt above is the result of tightening that gap — every constraint in it exists because something posted badly once.

Then turn on one platform. Then a second. Adding platforms to a working pipeline is easy; debugging six at once is not.