How to Automate Content Repurposing with AI (Free Tools, No Code)

You wrote a 1,500-word article. Now someone asks: "Is that on LinkedIn?" and "Did you send this to your list?" It isn't and you didn't, because repurposing takes time you don't have.

This tutorial shows you how to build a pipeline that takes one piece of long-form content and produces LinkedIn posts, short-form tweets, and an email snippet automatically. The whole stack is free to start, requires no code, and runs unattended once it's set up.

What you'll build

A workflow that:

Accepts a blog post URL or pasted text as input
Sends the content to an AI model with separate prompts for each output format
Saves the outputs to a Google Sheet (your content calendar)
Optionally emails you the drafts for quick review

Total setup time: 60 to 90 minutes.

Tools you'll need

| Tool | Free tier limit | Purpose | |------|----------------|---------| | Make.com | 1,000 operations/month | Workflow automation | | OpenRouter | Free credits on signup | AI API access | | Google Sheets | Unlimited | Content calendar | | Gmail or any SMTP | Unlimited | Email delivery |

Make.com's free tier is enough for most solo founders posting two to three times a week. OpenRouter gives you access to models like Claude and Llama through one API key, which keeps costs low.

Step 1: Set up your Google Sheet

Create a new Google Sheet with these columns:

A: Date
B: Source URL or title
C: LinkedIn Post
D: Tweet 1
E: Tweet 2
F: Email Snippet
G: Status

Name the sheet Content Repurposing. This is where every output will land.

Step 2: Get your OpenRouter API key

Go to openrouter.ai and sign up
Navigate to Keys and create a new key
Copy it somewhere safe

You'll use this key to call AI models from inside Make.com. The free credits are enough to get started. Once you're past the free tier, costs run roughly $0.002 per repurposing run using Claude Haiku or a similar small model.

Step 3: Build the Make.com scenario

Open Make.com and create a new scenario. Here is the module sequence:

Module 1: Trigger

Use a Webhook trigger. Make.com will give you a URL. You'll send content to this URL to kick off the workflow.

Alternatively, use Google Sheets: Watch New Rows if you prefer to paste content into a sheet and have the workflow pick it up automatically.

Module 2: HTTP request to OpenRouter (LinkedIn post)

Add an HTTP: Make a Request module with these settings:

URL: https://openrouter.ai/api/v1/chat/completions
Method: POST
Headers:
- Authorization: Bearer YOUR_OPENROUTER_KEY
- Content-Type: application/json
Body (JSON):

{
  "model": "anthropic/claude-haiku",
  "messages": [
    {
      "role": "user",
      "content": "Write a LinkedIn post based on this content. Keep it under 200 words. Start with a hook. End with a question to drive comments. No hashtags.\n\n{{1.content}}"
    }
  ]
}

Replace {{1.content}} with the variable from your trigger module that holds the article text.

Module 3: HTTP request (Tweet thread)

Duplicate Module 2 and change the prompt:

{
  "role": "user",
  "content": "Write 2 punchy tweets based on this content. Each tweet must be under 280 characters. Return them as Tweet 1 and Tweet 2 on separate lines. No hashtags.\n\n{{1.content}}"
}

Module 4: HTTP request (Email snippet)

Duplicate again and change the prompt:

{
  "role": "user",
  "content": "Write a 3-sentence email snippet for a newsletter. It should tease the main idea and link back to the source. Tone: direct and conversational.\n\n{{1.content}}"
}

Module 5: Parse the AI responses

Each OpenRouter response comes back as JSON. Use a JSON: Parse JSON module on each response to extract the text from choices[0].message.content.

Module 6: Write to Google Sheets

Add a Google Sheets: Add a Row module. Map:

Date: {{now}}
Source: {{1.title}} (from your trigger)
LinkedIn Post: parsed output from Module 2
Tweet 1: first line of parsed output from Module 3
Tweet 2: second line of parsed output from Module 3
Email Snippet: parsed output from Module 4
Status: draft

Module 7 (optional): Send yourself an email

Add a Gmail: Send an Email module. Put the LinkedIn post, tweets, and email snippet in the body. Subject: New content drafts: {{1.title}}.

This way you get a digest in your inbox and can review before posting.

Step 4: Test it

In Make.com, click Run once and send a test payload to your webhook. Use this curl command from your terminal:

curl -X POST "YOUR_WEBHOOK_URL" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Test article",
    "content": "Paste a few paragraphs of article text here."
  }'

Check your Google Sheet. Within 10 to 15 seconds you should see a new row with all four outputs populated.

If you see empty cells, check the JSON parse step. OpenRouter's response nests the text inside choices[0].message.content, so make sure your parse path matches that structure.

Step 5: Integrate with your writing tool

Now that the pipeline works, hook it into wherever you write:

If you use Notion: Add a button to your article database that triggers a Make.com webhook via a Notion automation. This sends the article body to your pipeline the moment you click "Publish."

If you use a CMS: Add a webhook on the "post published" event. Most headless CMS platforms (Contentful, Sanity, Ghost) support outbound webhooks in their free tiers.

If you just write in Google Docs: Use Google Apps Script to add a menu item that POSTs the document content to your webhook on demand.

Prompt tuning tips

The prompts above are starting points. Adjust them to match your voice:

Add a sentence like "Write in a direct, no-fluff style" or "Match the tone of a founder who ships fast"
If your LinkedIn audience is technical, say so: "The audience is software engineers and CTOs"
To enforce length strictly, say: "Return exactly 180 words. No more, no less."
For tweets, if you want a specific structure, describe it: "Start tweet 1 with a counterintuitive claim. Start tweet 2 with a stat or number."

Run the pipeline on five to ten of your older articles to generate a backlog of social content. Tweak the prompts until the output sounds like you. Then lock in the prompts and let the workflow run on autopilot.

What to do with the drafts

The sheet becomes your content calendar. Set the Status column to scheduled once you've copied a post into Buffer, Hypefury, or whatever tool you use to schedule. Set it to posted after it goes live.

Over time you'll have a log of every piece of content, its source, and what was published from it. That data is useful: you can see which source articles generated the most posts, which formats you publish most consistently, and where your backlog is piling up.

Scaling up

Once this is working, a few natural extensions:

Add a Slack module to post drafts to a channel instead of email
Add an image prompt module that generates a DALL-E or Ideogram prompt to pair with each LinkedIn post
Use a Router module to send different content types (podcast, article, video) to format-specific prompts
Add a Filter to skip repurposing if the source article is under 500 words

None of these require code. They're all Make.com modules you can add to the same scenario.

Recap

You now have a pipeline that:

Takes any long-form content as input
Generates a LinkedIn post, two tweets, and an email snippet in under 15 seconds
Saves everything to a Google Sheet for review and scheduling
Sends you an email digest so nothing gets lost

The bottleneck in most content operations is not writing the original piece. It's the work that comes after: adapting it, formatting it, and getting it distributed. This workflow removes that bottleneck without any ongoing manual effort.

Set it up once, then focus on writing the source content.