Automation6 min read

How I Built a Content Repurposer Using Make.com and Claude

Nevada Pascolini
Nevada Pascolini
March 11, 2026
Share
Content repurposing tool built with Make.com and Claude

Ever written a blog post and then dreaded the part where you have to turn it into LinkedIn posts, tweets, and email snippets? I built a simple tool that does it for you — paste in a blog URL and get ready-to-publish social content back in seconds. Here's how it works and how you can build your own.

What It Does

The Content Repurposer is a single-page web app. You paste a blog post URL, hit a button, and it returns multiple pieces of social media content — LinkedIn posts in different styles (short & punchy, story-style, contrarian, etc.), tweets, and email snippets — all generated from the original article.

The Architecture

The app has two parts:

1

A simple HTML frontend — a single index.html file with an input field, a button, and an output area

2

A Make.com webhook scenario — handles the heavy lifting: fetching the blog content, sending it to an AI model, and returning the repurposed content

The frontend sends the URL to Make.com, Make.com does the processing, and the result comes back as markdown which gets rendered in the browser.

How It Works

HTML Frontend

Paste URL, click button

Make.com Webhook

Receives POST request

Claude AI

Generates social content

Social Content

LinkedIn, tweets, email

The Frontend Code

The entire frontend is a single HTML file. Let's break it down.

The UI

Nothing fancy — just an input for the URL, a button, and a div to display results:

<input type="url" id="urlInput"
  placeholder="https://example.com/blog-post">
<button id="btn" onclick="repurpose()">
  Repurpose
</button>
<div id="output"></div>

Making the Request

When you click “Repurpose”, the app sends the URL to a Make.com webhook. I used XMLHttpRequest instead of fetch — and there's a good reason for that which I'll explain shortly.

const xhr = new XMLHttpRequest();
xhr.open('POST',
  'https://hook.eu1.make.com/your-webhook-id');
xhr.setRequestHeader(
  'Content-Type', 'application/json');
xhr.responseType = 'text';
xhr.onload = function() {
  output.innerHTML =
    marked.parse(xhr.responseText);
  btn.disabled = false;
};
xhr.send(JSON.stringify({ url: url }));

A few things to note:

responseType = 'text' — This forces the browser to treat the response as raw text, no matter what content-type header the server sends back

marked.parse() — The response comes back as markdown, so we use the marked.js library to convert it to nicely formatted HTML

Why XMLHttpRequest Instead of Fetch?

This was a lesson learned the hard way. My Make.com scenario was returning markdown content, but the webhook was sending it with a Content-Type: application/json header. The problem? The markdown content contained characters (smart quotes, asterisks, newlines) that made it invalid JSON.

With fetch and response.text(), the browser was still choking on the malformed response before I could read it. XMLHttpRequest with responseType = 'text' is more forgiving — it gives you the raw bytes as a string regardless of what the server claims the content type is.

Takeaway: If you're working with webhooks that return non-standard responses, XMLHttpRequest can save you a lot of headaches.

Loading State and Rendering Markdown

While waiting for the response (which can take a minute since it involves AI processing), I disable the button and show a loading message:

btn.disabled = true;
output.innerHTML =
  '<span class="loading">' +
  'Generating content... ' +
  'this may take a minute.</span>';

The response comes back as markdown with headings, bold text, lists, and horizontal rules. Rather than writing a custom parser, I pulled in marked.js via CDN:

<script src="https://cdn.jsdelivr.net/npm/
  marked/marked.min.js"></script>

Then rendering is a single line:

output.innerHTML =
  marked.parse(xhr.responseText);

The Make.com Scenario

The backend is a Make.com scenario with a webhook trigger. Here's the general flow:

1

Webhook trigger — Receives the POST request with the blog URL

2

HTTP module — Fetches the content from the blog URL

3

AI module — Sends the blog content to Claude with a prompt asking it to generate LinkedIn posts, tweets, and email snippets in different styles

4

Webhook response — Returns the generated content as markdown text

Important: Make sure your webhook response module is set to return text/plain rather than JSON. If the AI-generated content contains special characters (which it almost always will), wrapping it in JSON can cause parsing issues on the frontend.

Styling

The CSS is minimal — just enough to make the output readable:

#output {
  margin-top: 24px;
  line-height: 1.6;
}
#output h2 {
  border-bottom: 1px solid #ddd;
  padding-bottom: 6px;
}
#output hr {
  border: none;
  border-top: 2px solid #eee;
  margin: 24px 0;
}

The line-height: 1.6 keeps the generated content easy to read, and the subtle border under h2 elements helps visually separate sections (LinkedIn posts vs tweets vs email).

Lessons Learned

1

Don't assume your webhook response format — Test what actually comes back before writing your parsing logic. Console logging the raw response saved me a lot of time.

2

XMLHttpRequest still has its uses — fetch is great, but when you need to force a response to be treated as text regardless of headers, XHR gives you more control.

3

Use a markdown library — Don't roll your own markdown parser. marked.js is tiny and handles edge cases you won't think of.

4

Return plain text from webhooks when possible — If your response content is generated by AI, avoid wrapping it in JSON. The special characters in natural language will break JSON parsing more often than not.

Try It Yourself

The full source code is just a single HTML file — under 60 lines. Clone it, swap in your own Make.com webhook URL, and you've got a working content repurposer.

The Bottom Line

Content repurposing is one of those tasks that's perfect for automation — it's repetitive, time-consuming, and follows predictable patterns. With Make.com handling the orchestration and Claude handling the writing, you can go from blog post to a full suite of social content in under a minute. No more staring at a blank LinkedIn post wondering how to summarise your own article.

Get In Touch

Want us to build automations like this for your business?

We build workflow automations and system integrations that save hours of manual work every week. Book a discovery call to see what we can automate for you.

Book a Discovery Call

Keep Reading

More Articles

Back to Articles