# Fix Silent Failures When Publishing to Social Media

Your workflow runs. Every node shows a green checkmark. The execution log says "success." But when you open Instagram, LinkedIn, or Facebook, the post is not there. No error. No warning. Nothing.

This is the most frustrating category of bug on the [n8n forum](https://community.n8n.io) and [Make.com forum](https://community.make.com). One n8n user reported 183 successful executions with zero published posts. Make.com users share screenshots of Facebook automations that post image URLs as plain text instead of rendering the image. Instagram Reels fail with cryptic error codes like 2207026 and 2207052 that have no official documentation.

Here are the five most common causes of silent failures, how to diagnose each one, and a publishing approach that eliminates them.

## The five failure modes

### 1. Media URLs expire before the platform processes them

You generate an image with DALL-E or Midjourney. The API returns a temporary URL. Your workflow stores the URL in a variable and passes it to the Instagram publish node 30 seconds later. By then, the URL has expired. Instagram returns a 200 response (success) for the container creation, but the media never finishes processing.

On the Make.com forum, users report this with Google Drive and Dropbox links too. These services return redirect URLs or require authentication. Instagram, Facebook, and TikTok reject them silently.

**Fix:** Use media URLs that are permanent and publicly accessible. Blotato's [Create Visual](/api/create-video.md) API returns a `mediaUrl` hosted on Blotato's CDN. The URL does not expire. Pass it directly to the [Publish Post](/api/publish-post.md) endpoint -- no upload step required.

### 2. Instagram carousel creation requires a multi-step API flow

Instagram's Graph API requires three separate API calls to create a carousel post:

1. Create a media container for each image (one call per image).
2. Create a carousel container referencing all image containers.
3. Publish the carousel container.

Each step returns a different ID. If you pass the wrong ID to the next step, Instagram returns a success response but never publishes the post. On the Make.com forum, a user building carousels from Airtable described spending two weeks debugging this flow.

**Fix with Blotato:** Pass 2-10 image URLs in the `mediaUrls` array of a single [Publish Post](/api/publish-post.md) call. Blotato handles the multi-step container flow behind the scenes:

```json
{
  "post": {
    "accountId": "your-instagram-account-id",
    "content": {
      "text": "5 tips for morning productivity",
      "mediaUrls": [
        "https://example.com/slide1.jpg",
        "https://example.com/slide2.jpg",
        "https://example.com/slide3.jpg"
      ],
      "platform": "instagram"
    },
    "target": {
      "targetType": "instagram"
    }
  }
}
```

One API call. One response. One `postSubmissionId` to poll for status.

### 3. LinkedIn requires a Person URN lookup that fails silently

LinkedIn's API requires a "Person URN" (a unique identifier like `urn:li:person:abc123`) to publish posts. Getting this URN requires calling `/v2/me` with the correct OAuth scopes. If your developer app is configured with a separate posting account (a common setup), the `/v2/me` call returns the wrong URN. The post request succeeds in your workflow but LinkedIn rejects it server-side with no error surfaced to your automation tool.

On the n8n forum, a user described setting up a separate dev app and posting account, then spending days debugging why `/v2/me` returned a URN that LinkedIn refused.

**Fix with Blotato:** You connect your LinkedIn account once in [Settings](https://my.blotato.com/settings). Blotato stores and refreshes the credentials. Publish with the `accountId` from `GET /v2/users/me/accounts`:

```json
{
  "post": {
    "accountId": "your-linkedin-account-id",
    "content": {
      "text": "3 lessons from scaling a SaaS product",
      "mediaUrls": [],
      "platform": "linkedin"
    },
    "target": {
      "targetType": "linkedin"
    }
  }
}
```

For LinkedIn Company Pages, add `pageId` from `GET /v2/users/me/accounts/{accountId}/subaccounts` ([docs](/api/accounts.md#list-subaccounts-pages)).

### 4. Facebook image posts render as plain text URLs

Facebook's API requires images to be publicly accessible at a direct URL (not a redirect, not behind authentication). If you pass a Google Drive sharing link or a Dropbox link, Facebook accepts the request, creates the post, but displays the URL as plain text instead of rendering the image.

On the Make.com forum, multiple users report this issue. Their automation works during testing (because Facebook caches the image from a recent manual upload) but breaks in production when the cache expires.

**Fix with Blotato:** Pass any image URL in `mediaUrls`. Blotato downloads the image, re-hosts it on a public CDN, and passes the CDN URL to Facebook. The image renders every time:

```json
{
  "post": {
    "accountId": "your-facebook-account-id",
    "content": {
      "text": "New product launch!",
      "mediaUrls": ["https://example.com/product-photo.jpg"],
      "platform": "facebook"
    },
    "target": {
      "targetType": "facebook",
      "pageId": "your-page-id"
    }
  }
}
```

### 5. TikTok requires developer app approval with strict requirements

TikTok's Content Posting API requires a developer application with "direct post" scope approval. Many applications get rejected. Even after approval, TikTok's upload flow uses chunked video uploads and a multi-step publish confirmation. If any step fails, the workflow reports success (the upload completed) but the video never appears on TikTok.

On the n8n forum, users ask "Are there tools for automated posting on TikTok?" because the native TikTok integration does not exist in n8n. Make.com has no native TikTok publishing module either.

**Fix with Blotato:** Connect your TikTok account in [Settings](https://my.blotato.com/settings). Publish with the standard request structure, adding the required TikTok fields:

```json
{
  "post": {
    "accountId": "your-tiktok-account-id",
    "content": {
      "text": "5 productivity habits #productivity",
      "mediaUrls": ["https://example.com/video.mp4"],
      "platform": "tiktok"
    },
    "target": {
      "targetType": "tiktok",
      "privacyLevel": "PUBLIC_TO_EVERYONE",
      "disabledComments": false,
      "disabledDuet": false,
      "disabledStitch": false,
      "isBrandedContent": false,
      "isYourBrand": false,
      "isAiGenerated": true
    }
  }
}
```

## How to verify posts went live

Every Blotato publish request returns a `postSubmissionId`. Poll the [Get Post Status](/api/publish-post/get-post.md) endpoint to confirm the post reached the platform:

```
GET https://backend.blotato.com/v2/posts/{postSubmissionId}
```

The status field tells you what happened:

| Status       | Meaning                                |
| ------------ | -------------------------------------- |
| `publishing` | Post is being processed                |
| `published`  | Post is live on the platform           |
| `failed`     | Post failed -- check the error message |

Failed posts also appear at [my.blotato.com/failed](https://my.blotato.com/failed) with the error details.

In n8n, add a Blotato **Get Post Status** node after each Publish Post node. Enable polling until the status reaches `published` or `failed`. In Make.com, add an HTTP module polling the same endpoint.

## Step-by-step: n8n workflow with failure detection

1. Install the [Blotato community node](https://help.blotato.com/api/n8n/n8n-blotato-node) in n8n.
2. Add your trigger node (schedule, webhook, or Google Sheets).
3. Add a Blotato **Publish Post** node. Configure the platform, account ID, text, and media URLs.
4. Add a Blotato **Get Post Status** node. Pass the `postSubmissionId` from the Publish node. Enable polling until status reaches a terminal state.
5. Add an **IF** node. Check if the status is `published` (success path) or `failed` (error path).
6. On the error path, add a notification node (Slack, email, or Telegram) to alert you when a post fails.
7. Activate the workflow.

This turns silent failures into loud notifications.

## Step-by-step: Make.com scenario with failure detection

1. Add your trigger module (schedule, webhook, or Google Sheets).
2. Add an HTTP module calling `POST https://backend.blotato.com/v2/posts` with the `blotato-api-key` header and your post body.
3. Add a polling loop (Repeater + HTTP GET) to check `GET https://backend.blotato.com/v2/posts/{postSubmissionId}` until the status is `published` or `failed`.
4. Add a Router module. Route on the status value.
5. On the `failed` route, add a Slack or email module to send an alert with the error message.
6. Activate the scenario.

## Common error codes and solutions

| Error                  | Platform  | Cause                                            | Solution                                                     |
| ---------------------- | --------- | ------------------------------------------------ | ------------------------------------------------------------ |
| 2207026                | Instagram | Video format not supported or URL not accessible | Use MP4 format. Host on a public URL (not Google Drive).     |
| 2207052                | Instagram | Video upload timed out                           | Reduce video file size. Use a CDN-hosted URL.                |
| "Invalid image"        | Facebook  | Image URL returns a redirect or requires auth    | Use a direct, public image URL.                              |
| "Person URN not found" | LinkedIn  | Wrong OAuth scope or dev app configuration       | Re-authorize with `w_member_social` scope.                   |
| "Unauthorized"         | TikTok    | Developer app not approved for direct post       | Apply for TikTok Content Posting API access, or use Blotato. |

## Forum threads referenced

These are the community discussions that prompted this post:

* [Social Media Autoposter - Workflow Shows Success But Posts Not Publishing](https://community.n8n.io/t/social-media-autoposter-workflow-shows-success-but-posts-not-publishing-loop-data-flow-issue/250979) (n8n)
* [LinkedIn API + n8n Automation Issue: Not Getting Person URN](https://community.n8n.io/t/linkedin-api-n8n-automation-issue-not-getting-person-urn-from-v2-me-separate-dev-app-posting-account-setup/289503) (n8n)
* [Instagram Reels Error: Media upload has failed with error code 2207026](https://community.make.com/t/instagram-reels-error-media-upload-has-failed-with-error-code-2207026/27213) (Make)
* [Media upload has failed with error code 2207052 (Instagram reels)](https://community.make.com/t/media-upload-has-failed-with-error-code-2207052-instagram-reels/88655) (Make)
* [Automation Facebook posts with images](https://community.make.com/t/automation-facebook-postes-with-images/85552) (Make)
* [Facebook image not posting](https://community.make.com/t/facebook-image-not-posting/106708) (Make)
* [Airtable -> Instagram Carousel (help with multiple images)](https://community.make.com/t/airtable-instagram-carousel-help-with-multiple-images/17234) (Make)
* [Automated TikTok Posting?](https://community.make.com/t/automated-tiktok-posting/46988) (Make)
* [Are There Tools for Automated Posting on TikTok?](https://community.n8n.io/t/are-there-tools-for-automated-posting-on-tiktok/227817) (n8n)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://help.blotato.com/blog/fix-silent-failures-social-media-n8n-make.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.