How to Automate Content Creation and Repurposing with n8n

The Content Treadmill Stops Here

You publish a blog post. Then it sits there.

The LinkedIn summary never gets written. The Twitter thread never gets drafted. The newsletter excerpt never gets pulled. You know the content is there — you just never have time to repackage it.

n8n solves this by turning a single published piece into a full distribution pipeline. Write once, and the workflow handles the rest: summarize, adapt, schedule, and publish across every channel automatically.

What You Can Automate in Content Creation

• Blog-to-social repurposing — pull a published post via RSS or CMS API, generate 3 Twitter/X posts, a LinkedIn summary, and a short email excerpt, all in one workflow
• AI first drafts — feed a topic outline or bullet points into an LLM and get a structured draft back, formatted for your CMS
• Transcript-to-post pipeline — take a Zoom or podcast transcript, summarize with AI, reformat as a blog post, and create a Notion draft
• Content calendar filling — detect gaps in your publishing schedule and auto-generate topic suggestions or placeholder drafts
• Newsletter digests — aggregate your best-performing posts from the week and format them into a Beehiiv or Mailchimp campaign
• Social proof recycling — pull 5-star reviews or testimonials on a schedule, reformat as social posts, and queue them in your scheduler
• Internal knowledge publishing — convert Notion pages or Confluence docs into public-facing blog posts with a formatting pass

The Content Creation Pipeline

Trigger (RSS Feed / CMS Webhook / Schedule / Notion Event)
  → Fetch source content (HTTP Request / WordPress / Ghost node)
  → Extract key sections (Code node — strip HTML, segment headings)
  → Build prompt (Code node — inject title, excerpt, target format)
  → OpenAI node (generate repurposed variants per channel)
  → Parse output (Code node — split into individual pieces)
  → Route by channel (Switch node)
    → Twitter/X: post via API
    → LinkedIn: queue via Buffer / HTTP Request
    → Email: add to Mailchimp / Beehiiv campaign draft
    → Notion: create draft page for review
  → Slack notification: "Content distributed: <post title>"

For AI-first draft generation, the pipeline is shorter:

Webhook Trigger (form submission with topic + outline)
  → Code node: build structured prompt from form fields
  → OpenAI node: generate full draft
  → Google Docs node: create new document with draft
  → Slack DM: "Draft ready — <Google Docs link>"

Step-by-Step Breakdown

1. Collect

Set the trigger that kicks off the pipeline. The most common options:

• RSS Feed node — fires when a new post appears on your blog's RSS feed
• Webhook — your CMS (WordPress, Ghost, Webflow) sends a POST when a post is published
• Schedule Trigger — runs daily and checks for posts published in the last 24 hours via HTTP Request to your CMS API

For the transcript-to-post flow, the trigger is typically a Webhook from Zapier, Notion, or a file-upload form that delivers the raw transcript text.

2. Process and Segment

Strip out what you do not need. A raw CMS API response contains dozens of fields — you want the title, content, url, and published_at.

Use the Code node to:

• Strip HTML tags from the post body
• Split the content into intro, sections[], and conclusion
• Extract the top 3 headings for the social post bullet structure

// Code node: extract clean sections from HTML content
const raw = items[0].json;
const clean = raw.content.replace(/<[^>]+>/g, '').trim();
const headings = [...raw.content.matchAll(/<h2[^>]*>(.*?)<\/h2>/g)]
  .map(m => m[1].replace(/<[^>]+>/g, ''));

return [{ json: {
  title: raw.title,
  url: raw.url,
  intro: clean.slice(0, 300),
  headings: headings.slice(0, 3),
  full_text: clean,
}}];

3. Route

Use the Switch node to send different prompts to the AI node depending on the target channel. A LinkedIn post needs a professional tone and 150–200 words. A Twitter thread needs punchy sentences under 280 characters each. A newsletter excerpt needs a hook and a clear CTA.

Build a separate prompt template for each channel in the Code node, then pass the right one to the OpenAI node based on the Switch output.

4. Act

Call the OpenAI node with your formatted prompt. Set model to gpt-4o for quality drafts, or gpt-4o-mini for high-volume repurposing where cost matters.

For social posts, ask the model to return JSON so downstream nodes can parse each variant without brittle string splitting:

System: You are a content repurposing assistant. Return valid JSON only.
User: Repurpose the following blog post excerpt into:
  1. A Twitter/X thread (5 tweets, each under 280 characters)
  2. A LinkedIn post (150 words, professional tone)
  3. An email excerpt (2 sentences, hook + benefit)

Post title: <title>
Excerpt: <intro>
Key points: <headings joined by ", ">

Return format: { "twitter": ["tweet1", "tweet2", ...], "linkedin": "...", "email": "..." }

5. Follow Up

After generating and publishing, close the loop:

• Post a Slack message with the distributed content summary and links
• Log each run to a Google Sheet: post_title, date, channels_published, ai_tokens_used
• If the content goes to a review queue in Notion, add a reminder for the editor to approve within 24 hours

Implementation Patterns

Pattern 1: RSS → Multi-Channel Social Posts

Fires whenever a new blog post appears. Generates platform-specific copy and queues it for publishing.

RSS Feed Trigger (check every hour)
  → IF: published_at > last_run_timestamp
    → Code node: extract title, intro, top 3 headings
    → OpenAI node: generate Twitter thread + LinkedIn post + email excerpt (JSON output)
    → Code node: parse JSON into separate items
    → Split in Batches: process each channel
      → Switch: route by channel
        → Twitter/X: HTTP Request → POST to Twitter API v2
        → LinkedIn: HTTP Request → POST to LinkedIn Share API
        → Email: Mailchimp node → add to next campaign draft
    → Slack node: post summary to #content-ops

This runs fully unattended. New post published at 9am, social queue filled by 9:01am.

Pattern 2: Notion Brief → Google Docs Draft

An editor adds a content brief (title, target keyword, outline) to a Notion database. The workflow picks it up and returns a full first draft.

Notion Trigger (new row in "Content Briefs" database)
  → Code node: build prompt from title, keyword, and outline fields
  → OpenAI node: generate 800-word draft structured as intro + H2 sections + conclusion
  → Google Docs node: create new doc titled "DRAFT — <title>"
  → Notion node: update brief row with Google Docs link and status = "Draft Ready"
  → Slack DM to editor: "Draft ready: <title> — <Google Docs link>"

The editor opens a finished draft, not a blank page. Editing time drops from 2 hours to 30 minutes.

Pattern 3: Testimonial Recycling Queue

Pulls 5-star reviews from a spreadsheet or CRM on a weekly schedule, generates social-ready posts, and queues them in the content scheduler.

Schedule Trigger (every Monday 8am)
  → Google Sheets node: fetch reviews with rating >= 4 and "used" = false
  → Loop (Split in Batches: size 5)
    → Code node: build prompt "Rewrite this customer review as a compelling social proof post (max 100 words): <review_text>"
    → OpenAI node: generate post
    → HTTP Request: POST to Buffer queue (Twitter + LinkedIn)
    → Google Sheets node: mark review row "used" = true
  → Slack: "5 social proof posts queued for the week"

Run this once and your social calendar has authentic customer content for weeks.

n8n Nodes You'll Use Most

Getting Started

1. Pick your highest-volume bottleneck — where does content creation slow down most? If it is repurposing, start with Pattern 1. If it is first drafts, start with Pattern 2.
2. Connect your CMS — authenticate the WordPress, Ghost, or Webflow node (or set up an HTTP Request node for any CMS with a REST API). Test fetching a single post to confirm the payload shape.
3. Set up your OpenAI credential — add your API key in n8n's Credentials panel. Use gpt-4o-mini for volume tasks (repurposing, summaries) and gpt-4o for quality drafts.
4. Write your prompt templates — build one prompt per output format in a Code node. Test against three real posts before activating. Adjust tone and length constraints until the output is consistently usable.
5. Add a review step first — route AI output to Notion or a Slack thread for approval before connecting live publishing. Once you trust the output, remove the gate.
6. Connect your publishing targets — authenticate Twitter, LinkedIn, Mailchimp, or Buffer. Test posting to a staging account or a private channel before going live.
7. Activate and monitor — turn the workflow on, watch the first 5 executions in the n8n execution log, and verify the output quality. Set an error notification so you know if the AI node fails or a publishing API rejects a post.

For social media scheduling specifically, the Social Media Scheduler template gives you a ready-to-deploy queue structure. Pair it with the Content Distributor to generate and queue content in the same workflow.

If you want to classify incoming content (audience fit, topic category, sentiment) before routing it, How to Build AI-Powered Automations with n8n covers the exact classification pattern — the same Switch-on-AI-output structure applies directly here.

For teams already running social media workflows and wanting to add scheduling and analytics on top of content generation, How to Automate Social Media with n8n Workflows covers the publishing and engagement layer in detail.