How to Automate Content Repurposing with n8n

1 Receive the article URL with a Webhook

The Webhook node gives n8n a URL that accepts a POST request. You can call it from a publishing script, a form, or a no code tool each time a new article goes live.

Add a Webhook node to a new n8n workflow and configure:

Node: Webhook
HTTP Method: POST
Path: repurpose
Authentication: Header Auth
Respond: Immediately
Response Code: 200
Options > Response Data: {"status":"queued"}

Responding immediately matters because LLM calls can take a while, and most callers time out after 30 seconds. The body of the request is available under the body key in n8n.

Expression: {{ $json.body.url }}

{
  "url": "https://example.com/blog/zero-downtime-deploys",
  "tone": "practical",
  "platforms": ["social", "email", "thread"]
}

Use the Test URL while building and the Production URL once the workflow is active. The two paths differ in n8n, a common source of confusion.

2 Fetch the full article HTML

An HTTP Request node downloads the article so the n8n workflow can work with the complete text instead of a summary.

Add an HTTP Request node to the n8n canvas and configure:

Node: HTTP Request
Method: GET
URL: {{ $json.body.url }}
Response Format: Text
Put Output in Field: html
Options > Timeout: 20000
Options > Redirects > Follow Redirects: On
Settings > Retry On Fail: On
Settings > Max Tries: 3

{
  "html": "<article><h1>Zero Downtime Deploys</h1><h2>Why rolling updates matter</h2><p>...</p></article>"
}

Retry On Fail covers short outages if you trigger the workflow right after publishing and the page is still warming up, and n8n will try again.

3 Strip HTML and split by headings

An n8n Code node cleans the markup and cuts the article at each H2 heading. Splitting on headings gives the LLM a focused chunk with a clear topic, which produces tighter posts than feeding in the whole article at once.

Add a Code node and configure:

Node: Code
Mode: Run Once for All Items
Language: JavaScript

const html = $json.html || '';
const url = $('Webhook').first().json.body.url;
const main = (html.match(/<article[\s\S]*?<\/article>/i) || [html])[0]
  .replace(/<script[\s\S]*?<\/script>/gi, ' ')
  .replace(/<style[\s\S]*?<\/style>/gi, ' ');
const parts = main.split(/<h2[^>]*>/i).slice(1);
const clean = s => s.replace(/<[^>]+>/g, ' ').replace(/&nbsp;/g, ' ').replace(/\s+/g, ' ').trim();
const sections = parts.map(p => {
  const [head, ...rest] = p.split(/<\/h2>/i);
  return { sourceUrl: url, heading: clean(head), body: clean(rest.join(' ')) };
}).filter(s => s.body.split(' ').length >= 40);
return [{ json: { sections } }];

The filter drops sections shorter than 40 words, such as a short conclusion, because there is too little material to repurpose. Adjust the number to taste in the n8n Code node.

{
  "sections": [
    {
      "sourceUrl": "https://example.com/blog/zero-downtime-deploys",
      "heading": "Why rolling updates matter",
      "body": "Rolling updates replace instances one at a time so traffic keeps flowing..."
    }
  ]
}

4 Process each section with Split Out

The Split Out node converts the sections array into one n8n item per section, so the next nodes run once for each.

Add a Split Out node and configure:

Node: Split Out
Fields To Split Out: sections
Include: No Other Fields
Destination Field Name: (leave empty)

After this node, each item exposes sourceUrl, heading, and body at the top level. If a long article yields ten sections, the following LLM node runs ten times, so watch your API usage on very long posts when n8n loops.

5 Draft variants with an LLM API

Another n8n HTTP Request node sends each section to the LLM API. Asking for strict JSON output lets the next node read the three formats without fragile text parsing.

Add an HTTP Request node and configure:

Node: HTTP Request
Method: POST
URL: https://api.your-llm-provider.com/v1/chat/completions
Authentication: Generic Credential Type > Header Auth
Send Body: On
Body Content Type: JSON
Specify Body: Using JSON
Options > Batching > Items per Batch: 1
Options > Batching > Batch Interval: 1000
Settings > Retry On Fail: On

JSON Body:
{
  "model": "your-model-name",
  "temperature": 0.7,
  "response_format": { "type": "json_object" },
  "messages": [
    { "role": "system", "content": "Rewrite in your own words. Return JSON with keys social (max 260 characters), email (2 sentences), thread (array of 4 short posts)." },
    { "role": "user", "content": "Heading: {{ $json.heading }}\nText: {{ $json.body }}" }
  ]
}

Use the JSON.stringify helper inside the n8n expression if section text contains quotes that break the JSON body.

{
  "choices": [
    { "message": { "content": "{\"social\":\"Rolling updates keep traffic flowing while you ship.\",\"email\":\"Rolling updates swap instances one by one. Your users never see downtime.\",\"thread\":[\"1/ Deploys do not need downtime.\",\"2/ Replace instances gradually.\"]}" } }
  ]
}

6 Collect variants with Aggregate

An n8n Code node first expands each LLM reply into separate platform items. Then the n8n Aggregate node gathers them into one list so a single n8n Airtable operation can store the full set.

Node: Code
Mode: Run Once for Each Item

const v = JSON.parse($json.choices[0].message.content);
const src = $('Split Out').item.json;
return { json: { variants: [
  { sourceUrl: src.sourceUrl, section: src.heading, platform: 'social', variantText: v.social },
  { sourceUrl: src.sourceUrl, section: src.heading, platform: 'email', variantText: v.email },
  { sourceUrl: src.sourceUrl, section: src.heading, platform: 'thread', variantText: v.thread.join('\n') }
] } };

Node: Aggregate
Aggregate: Individual Fields
Input Field Name: variants
Options > Merge Lists: On

In n8n, Merge Lists flattens the nested arrays into a single array of variant objects.

7 Store variants in Airtable

Because the n8n Aggregate node produces one item holding an array, use a Split Out on the variants field again, then an n8n Airtable node to create records. Each record stores the source URL, platform, text, and a status for your review process.

Node: Airtable
Resource: Record
Operation: Create
Base: By ID (your base)
Table: Variants
Columns > Mapping: Define Below
sourceUrl: {{ $json.sourceUrl }}
section: {{ $json.section }}
platform: {{ $json.platform }}
variantText: {{ $json.variantText }}
status: Draft

{
  "id": "recAb12Cd34Ef56Gh",
  "fields": {
    "sourceUrl": "https://example.com/blog/zero-downtime-deploys",
    "platform": "social",
    "status": "Draft"
  }
}

Set up an Airtable view beside your n8n workflow, filtered by status Draft, and your editor can approve or reject variants in one place before anything is published.