n8n Error Workflows: Why Failure Alerts Don’t Arrive

Error Trigger not firing in n8n? Check manual vs automatic runs, the Error Workflow setting, Continue On Fail and alert delivery, then test safely.

perfectpoint
10–15 minutes
Article cover: n8n Error Workflows

When an n8n error alert doesn’t show up, ask four things in this order. Was the failing run automatic, not started from the editor? Did that execution really end as an error, or does it say Success? Is the error workflow selected in the settings of the workflow that failed? And does the error workflow have any execution of its own? Your answers land on one row of the diagnostic table below, and each row has a different fix.

Start with the Execution Status, Not the Alert

An alert can go missing in four different places. The fixes have nothing in common, so find your row before you change anything.

What you seeWhere to lookNext test
The main workflow has no execution at allMain workflow → ExecutionsIs it published? Fire the real trigger: send the webhook, wait for the schedule. If a trigger node broke, the handler may have run instead, so open its latest execution.
The main run says SuccessOpen the run, then each suspicious node → Settings → On ErrorSet the node to Stop Workflow, or add a check that ends in Stop And Error.
The main run says Error, the handler has no executionsMain workflow → Options → Settings → Error workflowRe-pick the handler, save, run one automatic test failure (see the five-minute test).
The handler ran, but nothing arrivedHandler → Executions → output of the alert nodePin the Error Trigger payload and run only the alert node by hand.

The first three rows are n8n problems. The fourth is a delivery problem: n8n did its job and Slack, Telegram or your mail server did not. If the handler has an execution, stop poking at the main workflow’s settings. You’re in the wrong place.

If the workflow starts with a Telegram Trigger and an incoming message creates no execution, first diagnose why the n8n Telegram Trigger is not receiving messages. That checks webhook registration, test versus production conflicts and trigger filters before you troubleshoot the error handler.

journey of an alert · 5 steps, 1 decision

Everything the handler does hangs on step 3. If that step reads Success, the last two never happen.

Why the Error Trigger Never Fired

You ran it by hand. This is the most common cause by a distance. The Error Trigger documentation says you can’t test error workflows with manual runs, because the node only fires when an automatic workflow fails. Clicking Execute workflow is a manual run. So is listening for a test event on a Webhook node and calling its test URL.

A good example is a forum post by Marcus_van_Geelen (30 January 2026, n8n Cloud 1.123.14). His handler worked when he executed it directly, but never fired when other workflows failed. Helper tamy.santos told him to use the real trigger instead of manual mode. He came back with a confirmation: it worked once he triggered it in production. The poster himself confirmed this one.

The setting is on the wrong workflow. You choose the error workflow in the settings of the workflow that fails: Options → Settings → Error workflow, then Save. Selecting something inside the handler does nothing. One handler can serve many workflows. The docs add that a workflow containing its own Error Trigger uses itself as the error workflow by default.

who holds the setting · 2 run types, 2 workflows

The failing workflow carries the setting and decides whether to call the handler. A manual run never gets that far.

That last default has a reported bug. On 9 October 2026 a GitHub user, danmunteanu1, opened issue #40824 on self-hosted 2.41.6. His report says that if a workflow with its own Error Trigger ever had the dropdown switched back to “No Workflow”, n8n stores the value DEFAULT, tries to run a workflow with that ID, and skips the workflow’s own Error Trigger. The only trace is a line in the server log. The issue is open and n8n has taken it into its tracker. I haven’t reproduced it. If you depend on a self-handling workflow and have touched that dropdown, a separate handler workflow is the safer setup. That part is my suggestion, not theirs.

The run succeeded, so there was nothing to handle. n8n calls the error workflow when an execution ends in an error, not when a node shows a red mark. Every node has an On Error setting with three choices in the docs: Stop Workflow, Continue, and Continue (using error output). With either Continue option, the failure is recorded on the node and the run carries on, usually ending green.

Forum helper Anshul_Namdev gave the same advice in a September 2026 thread: read the status on the execution itself, not on the node. Picture that thread’s setup, a Webhook into an HTTP Request that calls a dead address. If that HTTP Request had been set to Continue, you’d get a green run and zero handler executions, and nothing would be broken in n8n at all.

On Error settings · 3 paths, 3 outcomes

Same failure, three settings. Only the first ends the run as an error by itself.

The workflow never started. If the trigger node itself fails, there may be no execution to hand over. A forum user named Olek (March 2025, n8n Cloud 1.80.5) got an alert email full of undefined fields. His workflow’s last execution was 32 hours old. His Google Sheets trigger polled, got a 503, and n8n ran the handler with the trigger error. He worked it out himself from the docs. Per the docs, a trigger-level error sends a different payload: less in execution, more in trigger. An alert template built only for execution fields will print blanks.

Does the handler need to be published? The docs say no: if a workflow uses the Error Trigger node, you don’t have to publish it. The forum disagrees. In January 2026 mohamed3nan told a poster that in n8n 2 you must publish the error workflow. In September 2026 a helper named Lopez called an inactive handler “the most common cause” and said to look for the log line “is not active and cannot be executed”. Both are proposals. Neither poster confirmed it.

The log line is real, because it appears in the GitHub report above. But that case used a nonexistent workflow ID, so it only shows that n8n checks whether the target is active. It doesn’t prove an unpublished handler is rejected. I couldn’t test this on a live instance. Until you have tested your version, publish the handler if your editor lets you, and search your logs for that message if it still doesn’t fire. If Publish is unavailable for a workflow with only an Error Trigger, the docs claim holds for you.

Reproduce the Failure Safely in Five Minutes

I haven’t run this exact sequence for this article, so treat it as your test, not as our experiment. It uses a disposable workflow with a real automatic trigger, which is what the docs require.

  1. Build the handler. New workflow named Error handler (test). First node: Error Trigger. Second node: the alert node you’re actually debugging (Slack, Telegram or Send Email). Save.
  2. Build the victim. New workflow named ZZ error test. First node: Schedule Trigger, every minute. Second node: Stop And Error with the message Test failure from disposable workflow. The docs describe this node as the way to force a failure and trigger the error workflow.
  3. Connect them. In ZZ error test, open Options → Settings → Error workflow, choose Error handler (test), and Save.
  4. Run it for real. Publish ZZ error test and wait one minute. Then unpublish it right away, or it will spam you every minute. Forum helper Wouter_Nigrini gave the same warning.
  5. Check three places. First, ZZ error test → Executions: you expect one run that ended in Error. Second, Error handler (test) → Executions: you expect one run. Open it and read the payload. Third, your channel or inbox: the message should be there.

five-minute test setup · 2 workflows, 3 checks

The dashed link is the setting from step 3. The three boxes on the right are where the result shows up.

Don’t use Execute workflow as the proof test. It can’t prove anything here.

Whichever of the three places is empty tells you which row of the table you’re in. If the victim run shows Success, you misconfigured the test itself.

Here’s a trick from Wouter_Nigrini that I’d keep. Once the handler has run for real, copy its Error Trigger output and pin it on the Error Trigger node. You can then test the alert node with manual runs and real data. That separates “n8n didn’t fire” from “delivery broke” in one move.

One more case to know. Ayush_Singh2 (23 April 2026) ran his main workflow by hand, and it ended in a Stop And Error node. Three helpers offered three different fixes: publish it, check the handler really starts with an Error Trigger, and maybe Stop And Error counts as a “designed end” that doesn’t fire the handler. He wrote that it works now without saying which advice did it, so none of the three is confirmed. The docs, though, are explicit that Stop And Error is meant to trigger the handler. I’d discount the “exempt” theory.

The Run Is Green, but the Business Task Failed

n8n marks a run as failed only when something throws. Plenty of real failures don’t throw.

Here is a constructed example, not a real case. A lead form posts to a Webhook, an HTTP Request sends the lead to a CRM, and the CRM answers HTTP 200 with a body like {“ok”: true, “lead_id”: null, “note”: “duplicate, not created”}. As far as n8n is concerned, nothing went wrong. The run is green. The lead doesn’t exist.

The fix has two parts. First, decide what “worked” means in terms of data: here, that lead_id is not empty. Second, add an IF node that checks it, and send the false branch into Stop And Error with a message you’d want to read at 2 a.m.:

CRM returned 200 but created no lead. Submission: {{ $(‘Webhook’).item.json.body.submission_id }}

I use a submission ID rather than the person’s email. Alerts end up in chat channels and inboxes, and personal data shouldn’t travel there if you can avoid it.

before and after · constructed CRM example

The fix changes nothing else in the workflow. It only gives an empty result a way to fail.

The quieter version of the same problem is a node that returns zero items. Everything after it simply doesn’t run, and the execution still ends green. Put a check after any step whose empty output means failure, and end the “empty” branch in Stop And Error too.

This is separate from errors n8n already marks as failed. If the run is red and the handler stayed silent, go back to the table.

The Error Workflow Ran, but No Alert Arrived

Open the handler’s execution, then open the alert node. A red node means delivery failed, and the provider’s message is usually right there. A green node with nothing in your channel is rarer, and it usually means the node is set to On Error: Continue, or it posted somewhere you aren’t looking.

The usual suspects:

  • Credentials. An expired or revoked Slack, Gmail or Telegram credential fails exactly when you need it.
  • Telegram. The bot can’t message a person who hasn’t started a chat with it, and the chat ID must be right.
  • Slack. The bot has to be in the channel, unless it has the chat:write.public scope.
  • Email. Check spam first, then the SMTP or Gmail result.
  • Handler settings. The handler itself needs to be saved, and published if your version requires it (see above).

Here’s a message worth sending. It handles both payload shapes, so it doesn’t print blanks on trigger errors:

Workflow: {{ $json.workflow.name }}
Failed node: {{ $json.execution ? $json.execution.lastNodeExecuted : ‘trigger node’ }}
Error: {{ $json.execution ? $json.execution.error.message : $json.trigger.error.message }}
Run: {{ ($json.execution && $json.execution.url) || ‘no link available’ }}

Why the execution link may be missing. The docs list two reasons. execution.id and execution.url need the execution to be saved in the database. And they’re absent when the error is in the main workflow’s trigger node, because no workflow execution happened. If you want links on every alert, check that the failing workflow still saves failed production executions in its own settings.

Error Trigger payload · two shapes, fields from the n8n docs

Build the alert from fields that exist in both shapes, or branch on whether execution is present, as the template above does.

Final Troubleshooting Checklist

Work through these in order and stop at the first “no.”

  • ☐ The failing run was automatic, not started from the editor.
  • ☐ The main execution’s status is Error.
  • ☐ If it says Success: no node has On Error set to a Continue option, and no check swallowed the failure.
  • ☐ The main workflow’s Settings → Error workflow shows your handler, and you saved.
  • ☐ The handler starts with an Error Trigger node and is saved (and published, if your version needs it).
  • ☐ Self-hosted: the log shows no “not active”, “could not find workflow” or permission error. Lopez named those three on the forum.
  • ☐ The handler has an execution for the failure.
  • ☐ The alert node ran green, the credentials are valid, and the chat or channel is right.
  • ☐ The pinned payload test sends a message by hand.
  • ☐ Failed production executions are saved, so the link isn’t empty.

The next step is simple. Run the five-minute test once on a disposable workflow, then force one failure on your real workflow and watch the alert arrive. Before you hand a workflow to a client, settle who receives that message and who answers it. Our n8n client handover guide covers that responsibility split and an acceptance test that includes a forced failure.

FAQ

Can I test Error Trigger with Execute Workflow? No. The docs say error workflows can’t be tested with manual runs. You can run the handler by hand with a pinned payload to test the alert nodes, but that proves delivery, not triggering.

Does the error workflow need to be published? The current docs say no. Several forum answers about n8n 2 say yes. Test your own version, and publish it if the editor allows.

Why is the execution URL missing? Either the error happened in the main workflow’s trigger node, or the execution wasn’t saved. Both are in the docs.

WRITTEN BY

perfectpoint

Leave a Reply

TAGS

Keep the thread going.