Fix silent failures: when your automation says success but nothing posted
Short answer: A green run only means the posting service accepted your request. With Blotato, a software subscription that publishes to 11 social networks, the create call returns a submission ID at once and the actual publishing happens afterwards. To know the outcome, save that ID, wait at least 10 seconds, then look the post up with the status call, and treat published as the only success. Never resend a failed post until you have read the error.
The workflow shows a tick, the log shows 200 or 201, and the post is nowhere on the account. This page explains why, and gives you a check you can add in an hour.
I'm Ranjit, and I run Blur Studio: 15+ years building software, 120 apps taken live, and clients who have gone on to raise $10M+. I build AI systems and processes that help businesses do a lot more with a lot less time. I also work differently from most of what else is out there, more on that further down this page. Say hello.
Most "silent failures" are not silent. The information exists, but the automation never asked for it. This guide is about the pattern, and it applies to n8n (a workflow automation tool), Make and Zapier alike. The examples use Blotato, a posting service whose documentation describes the status model clearly.
This page may contain affiliate links from which Blur Studio earns commissions.
Why this happens: publishing is asynchronous
Asynchronous means the answer to your request is not the final result. Think of posting a letter: the post office stamping it is not the same as the letter arriving. A create-post call to Blotato returns a postSubmissionId with HTTP status 201, which means "received". Then Blotato sends the content to the platform, and the platform can accept, delay or reject it. Your automation tool saw the 201 and marked the step green.
Blotato lists the usual reasons a post fails after acceptance (on its own help blog, which is vendor material):
- A temporary media link expired before the platform downloaded it.
- An Instagram carousel goes through several steps, and one failed.
- A LinkedIn identifier lookup failed.
- A Facebook image was posted as a plain link, not as media.
- TikTok needed app approval or an account fix.
The same page reports one n8n forum user with 183 successful runs and zero published posts. That report is secondhand, so treat it as an illustration, not evidence. The lesson holds anyway: success counts mean nothing without a status check.
The four statuses you must handle
Blotato's get-post endpoint is GET https://backend.blotato.com/v2/posts/{postSubmissionId}, with the header blotato-api-key. It allows 60 requests a minute. It returns one of four statuses:
| Status | Meaning | What your automation should do |
|---|---|---|
in-progress | No failed, published or scheduled record yet. | Wait 10 seconds or more, check again, up to a limit. |
scheduled | Queued for the returned scheduledTime. | Record "Scheduled". Stop polling. This is not published. |
published | Live. Returns publicUrl when available. | Record "Posted" and the URL. |
failed | Returns errorMessage. | Record "Failed" and the message. Alert a person. |
Two traps. First, in-progress is a fallback: if the ID matches nothing (a typo, or an ID from another account), you also get in-progress, so a bad ID looks like a slow post. Second, one blog table on Blotato's help site shows a word publishing while its API reference pages show in-progress. The reference pages are the newer source, but build your loop to treat any unknown status as "keep waiting up to the limit".
Also keep three IDs apart: the submission ID from create, the schedule ID from the schedules calls, and the published-post ID from list or analytics calls. They are not interchangeable.
The status check pattern
- Save first. Write the submission ID to your log (a sheet row, a database, a variable) before doing anything else. If the workflow dies later, you still have it.
- Wait. At least 10 seconds before the first check and between checks. Blotato says status polling should be at least 10 seconds apart.
- Check with a cap. A fixed number of attempts or a total time, for example 12 checks over about 2 minutes. Store the ID and report when the limit is reached.
- Branch on the status using the table above.
- Write back the status, public URL or error to the log.
In n8n the Blotato node has a Post, Get operation, and if your installed version lacks it, an HTTP Request node does the same call. In Make, check whether your Blotato module has a status lookup. Blotato's docs say to inspect the installed module, and otherwise to use Make's HTTP module with the REST request. In Zapier there is no official Blotato app, so use Webhooks by Zapier for both calls.
If you want to see the loop as code, this small script (Node 18 or later) does the same thing. Run it by hand with a real ID to learn the shape before you build the automation version.
const BASE = "https://backend.blotato.com/v2";
async function waitForPost(id, apiKey, maxChecks) {
for (let i = 1; i <= maxChecks; i++) {
await new Promise((r) => setTimeout(r, 10000));
const res = await fetch(BASE + "/posts/" + id, {
headers: { "blotato-api-key": apiKey },
});
if (res.ok === false) {
console.log("Status call failed with HTTP " + res.status + ", will retry");
continue;
}
const body = await res.json();
if (body.status === "published") return { ok: true, url: body.publicUrl };
if (body.status === "failed") return { ok: false, error: body.errorMessage };
if (body.status === "scheduled") return { ok: true, scheduledFor: body.scheduledTime };
}
return { ok: false, error: "Gave up after " + maxChecks + " checks, ID " + id };
}
waitForPost("PASTE_SUBMISSION_ID", process.env.BLOTATO_API_KEY, 12).then(console.log);
The key comes from an environment variable, not from the file. Never paste a key into a chat, a shared file or a workflow's visible text.
Retry rules: when to try again and when not to
The dangerous retry is resending a create call. Blotato says there is no client-supplied idempotency header, meaning no way to tell it "this is the same request, do not post twice". Its docs say internal duplicate detection is not a guarantee. So the rules are about what you retry:
| Situation | Do this |
|---|---|
| Status call failed (network error or server error) | Retry the status call with the saved ID, with a delay and a cap. |
| Create call timed out and you have no ID | Do not create again yet. Check the Blotato Posts page, the List Posts call (GET /v2/posts, default window 7 days either side) and the schedules first. |
Status is failed | Read errorMessage and fix the cause. An unchanged retry usually fails again. |
| HTTP 429 (too many requests) | Stop calling that route, wait, lower the rate. Create post allows 30 requests a minute. |
| Authentication or subscription error | Wrong key: recopy it, including the trailing equals sign. Subscription problem: check billing. |
| HTTP 422 | A field is wrong. Fix the field the message names. |
| Slack or Discord says it "did not confirm the post" | Look in the channel before publishing again, because it may exist. |
For built-in retries: n8n's Retry On Fail setting allows at most 5 tries with at most 5,000 milliseconds between them, and the HTTP Request node does not read a retry-after hint. For longer waits, n8n recommends a loop with a Wait node. Use Retry On Fail on read calls only, not on the create call. In Zapier, only successful actions count as tasks, and replaying a whole run re-runs steps that already succeeded, which can double-post. In Make, error handler modules (Rollback, Break, Resume, Commit, Ignore) and the Router do not use credits.
Logs: where to look
- Blotato Logs (in the Developer Platform) show the payload, response and error for each request, and can be filtered by Posts, Videos, Media, Accounts, DM and by Processing, Failed or Success. Absence from a filtered list does not prove nothing was tried, so clear the filter.
- Your own log is the more important one. One row per post attempt: your content ID, destination, submission ID, time sent, status, public URL, error text.
- Your automation tool's execution history tells you what the workflow did, not what the platform did.
Suggested columns: content_id, account_id, platform, submission_id, sent_at, status, public_url, error_message, checks_used.
Alerts: make a failure loud
- n8n: set an Error workflow in Workflow Settings, starting with an Error Trigger node, and send yourself a message. The Stop And Error node lets you force a failure when your own check finds
failedor the cap is hit. - Make: add an error handler route that sends an email or a chat message.
- Zapier: send a message from a Path or a final step that only runs when your check fails. Check whether your plan includes automatic replay settings before relying on them.
- Daily check: a second small workflow that lists yesterday's rows with no public URL and emails the list. This catches the case where the whole workflow never ran.
Test plan with pass and fail criteria
| Test | Pass | Fail |
|---|---|---|
| Send a post with a media link that returns an error page. | Your log shows failed and an alert arrives. | The log says "Posted". |
| Schedule a post for tomorrow. | The log says "Scheduled", not "Posted". | It says "Posted". |
| Call the status endpoint with a made-up ID. | Your loop gives up at the cap and reports it. | The loop runs forever or reports success. |
| Stop the workflow after create, before checking. | The daily check lists the row. | No one notices. |
| Run the status check once with a deliberately wrong API key. | Your alert reports an authentication error and the loop stops. | The loop retries forever or reports success. |
Use a throwaway account for these, and never test rate limits by sending many create-post calls. Read-only status requests are the only safe way to probe limits. The API needs a paid Blotato plan, because generating a key ends the 7 day trial. Starter is $29 a month billed monthly as of November 2026.
When it is not your automation
If you are still choosing a posting tool, Blotato's site lists the plans, and the status model above is the main thing to compare across tools. Sometimes the platform is the cause: a rejected format, an account restriction, a daily cap or an unapproved app. Blotato's help says to read the exact error and contact support with the submission ID, the destination and the scheduled time with its timezone. See also post stuck on processing and n8n and Make error codes.
How this page was checked
The facts come from Blotato's get-post, publish-post, rate-limit, error-handling and publishing-status pages, its help blog on silent failures, n8n's error handling and rate-limit pages, Make's pricing FAQ and Zapier's task usage page. Last checked 21 November 2026, refreshed every 90 days. Blur Studio has not run Blotato itself, so the code and tests above are for you to run. Use the 7 day trial for the web app and a paid month for the API.
How I'd approach this
Add the check before you add anything new. Day 1: log every submission ID. Day 2: build the status loop with a cap of 12 checks. Day 3: write back the URL and the error. Day 4: add the alert. Day 5: run the test table on a throwaway account. If it still feels fragile, the free AI tools and a free AI brainstorm call can help you decide what is worth automating at all.
Questions people ask
Why does my workflow show success when nothing was posted?
The create call returns "received" with a submission ID. Publishing happens afterwards and can fail. Add a status check by submission ID after a 10 second wait.
What does in-progress mean in Blotato?
It is the answer when no failed, published or scheduled record exists yet. A wrong ID also returns it, so always use a check limit and verify the ID came from the create response.
Does Blotato send a webhook when a post is published?
Blotato's documentation describes none for post status. Poll the get-post endpoint instead. See webhooks and Blotato.
Can I just retry the create call?
Not blindly. There is no idempotency header, so a retry can post twice. Look for the existing post first, using the Posts page, List Posts and your log.
How often can I check status?
Blotato's limit is 60 requests a minute for the get-post route, and its guidance is at least 10 seconds between checks for one post.
Does Zapier replay cause duplicates?
Zapier says a replayed full run re-counts previously successful steps, so a post step that worked the first time can run again. Replay only from the failed step, and check for the existing post first.
Where do I see the exact error?
In the status response (errorMessage) and in the Logs page on Blotato, which shows payload, response and error per request.
More in this topic: Social media: automation with n8n, Make and Zapier (27 guides) →