# Repurpose a Blog Post or Video into Social Media Posts

You wrote a blog post. Or recorded a YouTube video. Or published a newsletter. Now you need to turn that content into posts for LinkedIn, Twitter, Instagram, TikTok, and Threads. Manually rewriting the same content six different ways takes hours.

This is one of the most common automation requests on the [n8n forum](https://community.n8n.io) and [Make.com forum](https://community.make.com). Users build workflows that scrape a URL, extract the text, feed it into ChatGPT, and then wrestle with each platform's API to publish. The scraping step breaks on paywalled sites. The AI step needs careful prompting per platform. The publishing step requires separate OAuth setups for each social network.

Here is a three-step workflow that handles all of it.

## The three-step pipeline

1. **Ingest**: Give Blotato a URL. It extracts the content (article text, YouTube transcript, TikTok transcript, PDF text, or audio transcription).
2. **Transform**: Blotato's AI rewrites the extracted content for each platform using custom instructions you provide.
3. **Publish**: Send the transformed content to each platform with one API call per platform.

## Step 1: Extract content from a URL

Use the [Create Source](https://help.blotato.com/api/create-source) endpoint. Pass the URL and tell Blotato what type of content it is:

```json
{
  "source": {
    "sourceType": "article",
    "url": "https://example.com/my-blog-post"
  },
  "customInstructions": "Summarize this article in 3 key takeaways. Write in first person."
}
```

For a YouTube video:

```json
{
  "source": {
    "sourceType": "youtube",
    "url": "https://www.youtube.com/watch?v=VIDEO_ID"
  },
  "customInstructions": "Extract the 5 most actionable tips from this video."
}
```

Supported source types: `article`, `youtube`, `tiktok`, `pdf`, `audio`, `twitter`, `text`, and `perplexity-query`.

The response returns an `id`. Poll the [Get Source](https://help.blotato.com/api/create-source/get-source) endpoint with that ID until the status is `completed`. The response includes the extracted and transformed text.

## Step 2: Publish to each platform

Take the extracted text and pass it to the [Publish Post](https://help.blotato.com/api/publish-post) endpoint for each platform. One API call per platform.

LinkedIn example:

```json
{
  "post": {
    "accountId": "your-linkedin-account-id",
    "content": {
      "text": "3 takeaways from my latest blog post:\n\n1. First point...\n2. Second point...\n3. Third point...\n\nRead the full post: https://example.com/my-blog-post",
      "mediaUrls": [],
      "platform": "linkedin"
    },
    "target": {
      "targetType": "linkedin"
    }
  }
}
```

Twitter example (same content, different platform):

```json
{
  "post": {
    "accountId": "your-twitter-account-id",
    "content": {
      "text": "3 takeaways from my latest blog post (thread):",
      "mediaUrls": [],
      "platform": "twitter",
      "additionalPosts": [
        { "text": "1. First point...", "mediaUrls": [] },
        { "text": "2. Second point...", "mediaUrls": [] },
        { "text": "3. Third point...\n\nFull post: https://example.com/my-blog-post", "mediaUrls": [] }
      ]
    },
    "target": {
      "targetType": "twitter"
    }
  }
}
```

## Step-by-step: n8n workflow

1. Install the [Blotato community node](https://help.blotato.com/api/n8n/n8n-blotato-node) in n8n (Settings > Community Nodes > search "Blotato").
2. Add a trigger node. Use a webhook (so you fire it when you publish a new post), a Google Sheets trigger (add URLs to a spreadsheet), or a schedule (check an RSS feed on a timer).
3. Add a Blotato **Create Source** node. Set the source type to `article` (or `youtube`, depending on your content). Pass the URL from the trigger. Add custom instructions describing how you want the content summarized.
4. Add a Blotato **Get Source** node. Connect it to the Create Source node. Pass the source ID. Enable polling until status is `completed`.
5. Add one Blotato **Publish Post** node per platform. Connect them in parallel from the Get Source node.
6. Map the extracted text into each Publish Post node's `text` field. Adjust the text per platform if needed (shorter for Twitter, longer for LinkedIn).
7. Activate the workflow.

For a full walkthrough of the Blotato node setup, see: [n8n Blotato Node](https://help.blotato.com/api/n8n/n8n-blotato-node)

## Step-by-step: Make.com scenario

1. Add a trigger module (webhook, Google Sheets, or RSS).
2. Add an HTTP module to call `POST https://backend.blotato.com/v2/source-resolutions-v3` with the `blotato-api-key` header and your source type and URL in the body.
3. Add a second HTTP module to poll `GET https://backend.blotato.com/v2/source-resolutions-v3/{id}` until status is `completed`. Use Make's built-in repeater or sleep module for polling.
4. Add a Router module after the source is complete.
5. Add one HTTP module per platform route, each calling `POST https://backend.blotato.com/v2/posts` with the platform-specific request body.
6. Activate the scenario.

## What you feed in vs. what comes out

| Input             | Source type        | Output                                                          |
| ----------------- | ------------------ | --------------------------------------------------------------- |
| Blog post URL     | `article`          | Extracted article text, transformed by your custom instructions |
| YouTube video URL | `youtube`          | Full transcript, transformed by your custom instructions        |
| TikTok video URL  | `tiktok`           | Transcript from the video                                       |
| PDF URL           | `pdf`              | Extracted text from the document                                |
| Audio file URL    | `audio`            | Transcription of the audio                                      |
| Raw text          | `text`             | Your text, transformed by custom instructions                   |
| Search query      | `perplexity-query` | AI-researched answer to your query                              |

## Scheduling repurposed posts

Instead of publishing immediately, stagger your posts across the week. Add `scheduledTime` or `useNextFreeSlot` to each publish request:

```json
{
  "post": { ... },
  "scheduledTime": "2026-04-07T09:00:00+00:00"
}
```

Or let Blotato pick the next open slot in your content calendar:

```json
{
  "post": { ... },
  "useNextFreeSlot": true
}
```

See [Build a Social Media Scheduler](https://help.blotato.com/blog/build-social-media-scheduler-n8n-make) for a full scheduling walkthrough.

## Forum threads referenced

These are the community discussions that prompted this post:

* [Posting automatically on social media with n8n and an API](https://community.n8n.io/t/posting-automatically-on-social-media-with-n8n-and-an-api/276334) (n8n)
* [Repurpose TikToks everywhere automatically](https://community.n8n.io/t/repurpose-tiktoks-everywhere-automatically/206913) (n8n)
* [Full Social Media Automation: AI Images + Trending Topics to Instagram, Facebook, LinkedIn](https://community.n8n.io/t/full-social-media-automation-ai-images-runware-trending-topics-perplexity-instagram-facebook-linkedin-auto-comments/249592) (n8n)
* [Free AI Social Media Content Generation Automation](https://community.make.com/t/free-ai-social-media-content-generation-automation/58101) (Make)
* [Automate Your Social Media Posting with the "Social Media Machine"](https://community.make.com/t/automate-your-social-media-posting-with-the-social-media-machine-built-in-make-com-ai/88205) (Make)
* [100% AI Powered Automated Social Media System](https://community.make.com/t/100-ai-powered-automated-social-media-system-step-by-step-tutorial/41202) (Make)