# Cross-Post to 9 Platforms from One Workflow

You want to publish the same post to Instagram, TikTok, LinkedIn, Facebook, X, Threads, Bluesky, Pinterest, and YouTube. You open n8n or Make.com and start building. One node per platform. Each node needs its own OAuth connection, its own request format, and its own error handling. By platform four, the workflow is a mess. By platform six, something breaks and you spend an hour debugging.

This is the most common question on both the [n8n forum](https://community.n8n.io) and [Make.com forum](https://community.make.com). Users ask: "Which nodes do I need to post to all platforms?" The answer is always a long list of separate integrations, each with its own pitfalls. Here is why that approach fails, and a workflow that replaces it.

## Why per-platform integrations break

Each social platform has a different API:

* **Instagram** requires the Facebook Graph API with a two-step media container flow. No native module in Make.com handles carousels or Reels without custom HTTP calls.
* **TikTok** requires developer app approval. Many users report their applications getting rejected. The upload flow uses chunked uploads and a multi-step publish confirmation.
* **X (Twitter)** uses OAuth 1.0a for media uploads. The n8n native X node has known issues with image and video posting.
* **LinkedIn** has a separate upload flow for videos vs. images. Video requires a pre-registered upload URL, a binary PUT, then a post referencing the uploaded asset.
* **Facebook** needs a `pageId` from a subaccounts call. Video uploads go through a different endpoint than image uploads.
* **YouTube** requires OAuth2 with the YouTube Data API v3. Videos under 60 seconds with vertical aspect ratio become Shorts.
* **Threads, Bluesky, Pinterest** each have their own authentication and posting requirements.

Building and maintaining nine separate integrations means nine points of failure. When Meta changes the Graph API (which happens often), your Instagram and Facebook nodes break. When X deprecates an auth method, your Twitter node breaks. You spend more time fixing integrations than creating content.

On the n8n forum, one user described it this way: "I tried using the IF node to route posts per platform, but each platform needs different fields, different media handling, and different error responses. The workflow became unmaintainable."

## The unified approach: one API call per platform

With the [Blotato Publish API](https://help.blotato.com/api/publish-post), each platform publish is one POST request with the same structure. The only fields that change are `platform`, `targetType`, and `accountId`.

Here is a post to Instagram:

```json
{
  "post": {
    "accountId": "your-instagram-account-id",
    "content": {
      "text": "Your caption here",
      "mediaUrls": ["https://example.com/image.jpg"],
      "platform": "instagram"
    },
    "target": {
      "targetType": "instagram"
    }
  }
}
```

Here is the same post to LinkedIn:

```json
{
  "post": {
    "accountId": "your-linkedin-account-id",
    "content": {
      "text": "Your caption here",
      "mediaUrls": ["https://example.com/image.jpg"],
      "platform": "linkedin"
    },
    "target": {
      "targetType": "linkedin"
    }
  }
}
```

Same structure. Same endpoint. Blotato handles the platform-specific upload flows, media processing, and authentication behind the scenes.

## 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 Google Sheets trigger (read from a content spreadsheet), a webhook, or a schedule.
3. Add one Blotato **Publish Post** node per platform. Connect them in parallel from the trigger.
4. In each node, set the platform (Instagram, LinkedIn, TikTok, etc.) and pass the corresponding `accountId`.
5. Pass the same `text` and `mediaUrls` into each node.
6. Run the workflow.

Each Blotato node returns a `postSubmissionId`. Add a Blotato **Get Post Status** node after each publish if you need to confirm the post went live.

For platform-specific setup guides, see:

* [n8n Blotato Node](https://help.blotato.com/api/n8n/n8n-blotato-node)
* [n8n Slideshows and Carousels](https://help.blotato.com/api/n8n/n8n-slideshows-and-carousels)

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

1. Add a trigger module (Google Sheets, webhook, or RSS).
2. Add a Router module after the trigger.
3. Add one HTTP module per platform route, each calling `POST https://backend.blotato.com/v2/posts` with the `blotato-api-key` header.
4. In each HTTP module, set the request body with the platform-specific `accountId`, `platform`, and `targetType`.
5. Pass the same `text` and `mediaUrls` into each route.
6. Run the scenario.

For a full walkthrough, see: [Make.com Blotato Integration](https://help.blotato.com/api/make.com/make-blotato-integration)

## Step-by-step: Claude Code

Claude Code connects to Blotato through the API. From your terminal:

1. Get your connected accounts by calling `GET /v2/users/me/accounts` to retrieve each platform's `accountId`.
2. Write a script (or let Claude Code write one) that loops through your accounts and calls `POST /v2/posts` for each platform.
3. Pass the same content to each call, changing only `accountId`, `platform`, and `targetType`.

See: [API Reference](https://help.blotato.com/api/api-reference/publish-post)

## Adapting content per platform

Cross-posting does not mean posting identical text everywhere. Each platform has different character limits, hashtag conventions, and audience expectations. You have two options:

**Option 1: Same text, different formatting.** Post the same core message but adjust formatting. LinkedIn supports longer text. X has a 280-character limit (use `additionalPosts` for threads). TikTok and Instagram prioritize the first line as a hook.

**Option 2: AI-generated platform-specific text.** Use the [Create Source](https://help.blotato.com/api/create-source) endpoint with `sourceType: "text"` and `customInstructions` to rewrite your post for each platform:

```json
{
  "source": {
    "sourceType": "text",
    "text": "Your original post text here"
  },
  "customInstructions": "Rewrite this for LinkedIn. Use a professional tone. Add line breaks for readability. Keep it under 1300 characters."
}
```

Run this for each platform with different instructions, then publish the rewritten versions.

## Platform support reference

| Platform    | `platform` / `targetType` value | Requires `pageId` | Media support                 |
| ----------- | ------------------------------- | ----------------- | ----------------------------- |
| Instagram   | `instagram`                     | No                | Images, videos, carousels     |
| TikTok      | `tiktok`                        | No                | Videos, image carousels       |
| LinkedIn    | `linkedin`                      | Yes               | Images, videos, carousels     |
| Facebook    | `facebook`                      | Yes               | Images, videos, carousels     |
| X (Twitter) | `twitter`                       | No                | Images, videos, threads       |
| Threads     | `threads`                       | No                | Images, videos, carousels     |
| Bluesky     | `bluesky`                       | No                | Images, videos                |
| Pinterest   | `pinterest`                     | No                | Images, videos                |
| YouTube     | `youtube`                       | No                | Videos (Shorts and long-form) |

For platforms that require `pageId` (Facebook and LinkedIn), fetch it from `GET /v2/users/me/accounts/{accountId}/subaccounts` ([docs](https://help.blotato.com/api/accounts#list-subaccounts-pages)).

## Scheduling cross-posts

Instead of publishing to all platforms at the same time, stagger your posts. Add `scheduledTime` to each request:

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

Or use `useNextFreeSlot` to let Blotato pick the next open slot in your content calendar for each platform:

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

Both fields are top-level (siblings of `post`, not nested inside it). 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:

* [Automating posting for multiple social media](https://community.n8n.io/t/automating-posting-for-multiple-social-media/48086) (n8n)
* [Posting to multiple social media accounts](https://community.n8n.io/t/posting-to-multiple-social-media-accounts/71347) (n8n)
* [Is it possible to use N8N Self Hosted as a social media post scheduler?](https://community.n8n.io/t/is-it-possible-to-use-n8n-self-hosted-as-a-social-media-post-scheduler/228892) (n8n)
* [Posting to social media platforms automatically - which nodes needed?](https://community.n8n.io/t/posting-to-social-media-plattforms-automatically-which-nodes-needed/8073) (n8n)
* [Social Media Cross-Posting Automation Inquiry](https://community.make.com/t/social-media-cross-posting-automation-inquiry/37129) (Make)
* [AI Social Media System Posts to 9 Platforms](https://community.make.com/t/ai-social-media-system-posts-to-9-platforms/76840) (Make)