n8n Content Automation: Repurpose and Distribute Posts Automatically

Publishing a blog post used to mean one action. Now it means five: write the post, extract a LinkedIn summary, condense it to 280 characters for Twitter/X, draft the newsletter intro, create a Notion summary card. None of that work changes the content. It just moves it.

n8n content automation handles that distribution layer entirely. A single workflow fetches the source, passes it through an AI rewriting step, and routes platform-specific variants to each channel simultaneously. The post publishes once. Everything else runs without anyone watching.

The time savings are real. Teams running this pattern consistently report 3 to 4 hours less per post on manual adaptation work. The bigger return is consistency: every channel gets updated on publish day, with copy shaped for its format rather than awkwardly pasted from the original.

What n8n Content Automation Actually Solves

Distribution isn't a creative problem. It's a coordination problem. The source content exists. The destinations are known. The missing piece is a system that connects them without requiring a person to remember every step.

What a content automation workflow handles:

• Generating LinkedIn article summaries from blog posts, tone adjusted for professional context
• Writing Twitter/X threads by breaking long-form content at natural section boundaries
• Drafting email newsletter intros with a CTA pointing back to the full article
• Creating Notion summary cards with key points tagged and linked
• Queuing Buffer posts from an RSS feed trigger at configurable intervals
• Generating short-form Threads or Instagram captions per post
• Archiving published content to Airtable with metadata for future repurposing

The Content Distribution Pipeline

The core flow has five stages:

Trigger (Webhook or Schedule)
  → HTTP Request (fetch full article HTML)
  → Code (strip tags, normalize text)
  → OpenAI (generate all channel variants in one call)
  → Code (parse JSON response, trim to character limits)
  → Switch (route by destination)
      → LinkedIn: HTTP Request to LinkedIn API
      → Twitter/X: HTTP Request to Twitter v2 API
      → Email:    Gmail or SMTP node
      → Notion:   Notion node
  → Notion (archive log: which channels received the post)

The OpenAI call returns all variants at once rather than chaining separate AI nodes per channel. One call. Costs one API request. And it keeps context coherent across variants — the LinkedIn summary and the Twitter thread won't contradict each other because they're generated from the same prompt context.

Step-by-Step: Building the Workflow

1. Collect: Trigger and Fetch the Source

Two entry points work well: an RSS feed node (n8n-nodes-base.rssFeedRead) that polls for new posts every 6 hours, or a Webhook node that fires when a CMS emits a publish event. Either way, the first real task is fetching the full post content.

Don't use the RSS contentSnippet field directly. Most RSS feeds truncate at 500 characters and include raw HTML tags that break the prompt. Use the link field to fetch the full article with an HTTP Request node (n8n-nodes-base.httpRequest v4.2), then strip HTML in a Code node:

const clean = $input.item.json.html
  .replace(/<[^>]+>/g, ' ')
  .replace(/\s+/g, ' ')
  .trim();
return [{ json: { title: $input.item.json.title, url: $input.item.json.url, body: clean } }];

2. Process: Generate Channel Variants

The @n8n/n8n-nodes-langchain.openAi v2.1 node runs a single prompt that returns all channel variants in one structured JSON response. Format the prompt to return an object with one key per destination:

{
  "linkedin": "...",
  "twitter_thread": ["tweet 1", "tweet 2", "tweet 3"],
  "email_intro": "...",
  "notion_summary": "..."
}

Output lands at $json.output[0].content[0].text. That field is a string, not parsed JSON. The next Code node runs JSON.parse(...) to turn it into an object before routing.

3. Route: Split by Destination

A Switch node reads the parsed object and routes to the correct output branch. One behavior to know: n8n's Switch node fires to a single matching branch per execution item by default. That means a single item can't go to LinkedIn and Twitter in the same Switch pass.

The workaround is splitting the variants into separate items in the Code node — one item per channel — and letting n8n's default item iteration route them in sequence. Or use parallel IF nodes before the Switch. Either approach works. The split-in-Code method is simpler to debug.

4. Act: Post to Each Channel

LinkedIn's API requires an OAuth token and a two-step flow: create the post object, then publish it. The HTTP Request node (n8n-nodes-base.httpRequest v4.2) handles both calls. Twitter/X v2 API accepts a POST to the tweets endpoint with OAuth 2.0 credentials configured in n8n's credential store.

For email, the Gmail node or SMTP node takes the email_intro variant and a subject line. You can generate the subject as a fifth key in the prompt — "email_subject": "..." — and pull it through the same parse step. Worth adding. It's one extra JSON key and removes one manual task.

5. Archive: Log What Published

After all channel branches complete, a Notion node creates a record in a "Published Content" database. The record stores the original URL, publish timestamp, and which channels received updates. Three weeks from now when someone asks whether a given article was ever tweeted, the answer is in Notion. It won't be in anyone's memory.

Three Distribution Patterns Worth Knowing

Pattern 1: RSS deduplication. A Schedule trigger fires the RSS node every 6 hours. A Code node reads the latest guid and checks it against an Airtable "seen GUIDs" column. If the GUID already exists, the workflow exits via a Stop and Error node. If it's new, the pipeline continues. Simple, no external deduplication service required.

Pattern 2: Bulk backlog repurposing. An Airtable spreadsheet holds 50 older posts that never got distributed across channels. A Schedule trigger fires once daily, reads the next unprocessed row via n8n-nodes-base.airtable, runs the full pipeline, then marks the row as processed. At one post per day, a 50-item backlog distributes itself over 7 weeks without any manual intervention. The Smart Distribution Scheduler template implements exactly this pattern, with the queue logic and deduplication already built.

Pattern 3: Approval gate before posting. This is the pattern teams skip and then regret. Not every AI-generated variant is ready to publish without a review pass. The Content Distributor template includes an optional approval step: after the AI generates variants, a Slack message goes to the content manager with the drafted copy and Approve or Reject buttons. If no response arrives within 24 hours, the variants route to a Notion review queue rather than posting automatically.

n8n Nodes for Content Automation

Getting Started in Seven Steps

1. Set up the trigger. Use RSS for passive polling or Webhook for immediate publish-on-publish behavior. If you're using RSS, add the deduplication Code node immediately after.
2. Add the HTTP Request node to fetch the full article HTML. Wire the link field from the RSS node as the URL parameter.
3. Add a Code node to clean the HTML. Strip tags, collapse whitespace, and output a normalized object with title, url, and body fields.
4. Add the OpenAI node. Use @n8n/n8n-nodes-langchain.openAi v2.1. Write the prompt to return a JSON object with one key per destination channel. Test the prompt in OpenAI Playground first — iterating there is faster than debugging inside n8n's canvas.
5. Add a Code node to parse $json.output[0].content[0].text. Extract each key. Trim twitter_thread items to 280 characters. Keep linkedin under 3,000.
6. Wire the routing logic. Split variants into per-channel items in the Code node, then let n8n's item iteration route them in sequence to the correct output nodes.
7. Add the Notion archiving step last, after all channel branches complete, to log which channels received the post.

The Content Distributor template ships with the full pipeline pre-wired: RSS trigger, deduplication, OpenAI variant generation, Switch routing, and LinkedIn, email, and Notion branches. The approval gate is disabled by default. Drop in your credentials and it's running.

Content distribution shouldn't require human coordination every time a post goes live. It's a routing problem, not a creative problem. The AI step handles the creative adaptation — writing for each platform's format and tone. But the pipeline itself is pure logistics, and logistics is exactly what n8n content automation workflows are built for.

For deeper coverage of scheduling and platform-specific timing, the n8n social media automation guide covers posting cadences and engagement timing logic. If you're new to the OpenAI node and want to understand how output paths and structured responses work, the n8n OpenAI workflows guide covers prompt design and parse patterns in detail.

The Social Media Designer template pairs well with this pipeline — it generates image prompts and visual metadata per post variant, so LinkedIn cover images and Twitter card art get created in the same workflow run.