Make Event Subscriptions: Get Instant Scenario Error Alerts. Setup, Limits and Pitfalls
With event subscriptions, Make sends events such as failed scenario runs or changed scenarios straight to a URL you choose, via webhook. The feature is in open beta and only available on the Teams plan (three subscriptions per organization) and Enterprise. Your receiver has to cope with duplicates, retries and signatures, and the failure event also fires on warnings.
What are Make event subscriptions?
Event subscriptions let you subscribe to events in your Make organization: when something happens, Make immediately sends a message to an address you define. Technically this is a webhook, an HTTP request carrying the event data to an endpoint (a URL that accepts messages). According to the Make Help Center, the feature launched on October 8, 2026. On November 5, 2026, Make presented it in detail as a Feature Spotlight in the community forum, explicitly as an open beta that may still change before general availability.
The point: a broken scenario no longer ends up somewhere in an inbox. It lands right where your team already looks. And because one subscription covers the whole organization or a team, you don't have to fit every single scenario with an error route just to find out something went wrong. In our overview of Make Waves '26 the feature was only a table row. This article is about using it in practice.
Which events does Make send?
Make sends eleven event types. One covers failures, the rest cover changes. The full list is in the event types reference:
| Event | When it fires |
|---|---|
execution.failed |
A scenario run reports an error or a warning |
scenario.created |
A scenario is created |
scenario.updated |
A scenario is changed |
scenario.settings_updated |
A scenario setting changes, with old and new value |
scenario.activated / scenario.deactivated |
Scheduling for a scenario is switched on or off |
scenario.restored |
A scenario is restored from the trash |
custom_role.created / .updated / .deleted |
A custom role is created, changed or deleted |
team.created |
A new team is created |
Two details that no announcement mentions, but that matter day to day:
- Warnings trigger
execution.failedtoo. If you push every event unfiltered into a chat channel, you get more alerts than real outages. Check the includedstatusfield before you raise an alarm. - The scenario name and a link are missing. Among other things, the event contains
scenario_id,execution_id, the error message (message),app_nameandmodule_name. If you want a readable alert like "Lead import failed at HubSpot", you have to look up the name yourself or maintain your own mapping.
Who can use event subscriptions?
Only organizations on the Teams or Enterprise plan. According to the Make documentation, the Teams plan includes three subscriptions per organization, Enterprise unlimited. By default, Owners and Admins can create them. Anyone else needs a custom role with the right permission, and custom roles are Enterprise only.
Watch the limit: deactivated subscriptions count too. If you need room on the Teams plan, you have to delete an old subscription. Switching it off is not enough.
On the Core or Pro plan, you are left with error handling inside the scenario itself. According to the Make pricing page, the error handler modules Rollback, Break, Resume, Commit and Ignore don't consume credits. They don't replace the organization-wide view, though.
How do you set up a subscription?
In six steps, based on the Feature Spotlight and the Make documentation:
- In Make, go to Org > Utilities > Event subscriptions and click Create event subscription.
- Enter a name and the target URL. It has to be publicly reachable over HTTPS.
- Send a test event and check that it arrives.
- Choose the events: all or selected ones. "All" includes types Make adds later. For scenario events, you pick which teams are monitored.
- Save with Create.
- Copy the signing secret from the subscription details into your receiver (more on that below).
Afterwards, the Logs tab shows every delivery with event type, team, status, response code, time and payload. That is your first stop when an alert doesn't arrive.
Where should you send the events?
The simplest option is a separate Make scenario with a webhook trigger that filters the alert and forwards it to Slack, Teams or email. Make also mentions forwarding to PagerDuty (an alerting service for on-call teams) and to a SIEM, a system that collects and analyzes security events.
Our take on two pitfalls when you receive events with a Make scenario:
- Avoid the loop. If your receiving scenario fails itself, it creates a new
execution.failedthat lands right back at it. Put the receiving scenario in its own team and leave that team out of the monitored teams for scenario events. - Same point of failure. If Make itself has an outage, a Make scenario may not alert you at all. For critical processes, the receiver belongs outside of Make, for example as a small serverless function or directly in a monitoring tool.
What does your receiver need to handle?
Three things: spotting duplicates, acknowledging fast and verifying the signature. According to Make, delivery is "at-least-once": every event arrives at least once, but possibly twice and not always in the right order.
- Duplicates: The
Webhook-Idheader stays the same across retries and, according to the receiving docs, is the key for filtering them out. If you have already processed an Id, simply acknowledge it again. - Acknowledging: Any direct response with a 2xx code counts as accepted. Redirects (3xx) are not supported, and 4xx, 5xx and timeouts count as failures.
- Retries: Make retries up to ten times. The wait starts at 30 seconds and doubles until it reaches 4 hours 16 minutes before the last attempt. After that, the delivery is "Failed" and the subscription shows "Failing". A deactivated subscription buffers nothing: whatever happens in the meantime never reaches you.
- Signature: Make follows the Standard Webhooks specification. The signature is an HMAC-SHA256 over the combination of
Webhook-Id,Webhook-Timestampand the unmodified raw request body. The secret starts withwhsec_. According to the signature docs, you should reject requests whose timestamp is off by more than five minutes. Ready-made libraries are available at standardwebhooks.com.
The most common mistake when verifying: parsing the body as JSON first and then serializing it again. The signature will never match, because it was calculated over the raw bytes.
How does this compare to the n8n Error Workflow?
n8n solves the problem per workflow, Make now does it for the whole organization. In n8n, according to the n8n docs, you attach an error workflow with the Error Trigger in the settings of each workflow.
| Make event subscriptions | n8n Error Workflow | |
|---|---|---|
| Scope | Organization or team | set individually per workflow |
| Setup | Org > Utilities, Teams or Enterprise only | Options > Settings in the workflow |
| Name and link to the run | not in the event | workflow.name, execution.url |
| Changes to scenarios | yes, separate events | no |
| Receiver | external HTTPS URL | workflow in the same instance |
So n8n gives you the more readable alert, Make the more complete overview, including a change log. If you are torn between the two tools, the cost side is covered in Make vs n8n.
What does this mean for you?
If you run business-critical scenarios on the Teams plan, set the feature up now, even in beta. Our suggestion for the three subscriptions:
- Failures: only
execution.failed, filtered to real errors, sent to the channel your team actually reads. - Changes:
scenario.updated,scenario.settings_updated,scenario.activatedandscenario.deactivatedinto a log, such as a spreadsheet. That way you can see who switched a scenario off and when, if a process suddenly stops. - Spare: keep it free for tests or a second receiver. Remember that deactivated subscriptions take up the slot.
If you are on Core or Pro, upgrading just for this feature rarely pays off. Well built error routes in your most important scenarios do more there. If you want help making your automations more robust, talk to our n8n and Make agency.
Frequently asked questions
Do event subscriptions consume credits in Make?
The Make documentation doesn't say. If you receive the events with your own Make scenario, that scenario runs like any other, so plan for it.
Can I change the retry schedule?
No. According to Make, the retry schedule is fixed and cannot be adjusted.
Will I get missed events if my endpoint was down for a day?
Only within the retry window. After that, the delivery counts as failed. The Logs tab shows you what did not arrive.
Does this work on a Make Private Instance?
According to Make, custom roles with permissions for event subscriptions are not available on Private Instances. Whether the feature is otherwise available there is best confirmed directly with Make.
Sources
Tell us what you're planning. You'll get an honest assessment within 24 hours.
More articles