Error handling in Make.com scenarios

Reliable automations in make.com depend on clear, predictable error handling. This guide explains how to configure error handling so your scenarios recover gracefully, notify the right people, and keep your data accurate even when something goes wrong.

The instructions below are based on the official error-handling documentation and walk you through the concepts, options, and recommended settings step by step.

Key error-handling concepts in Make.com

Before changing settings, it is important to understand how make.com processes operations and where errors can occur in a scenario.

• Scenario: A complete automation that processes data from start to finish.
• Route: One path through the scenario, containing a series of modules.
• Module: A single step (for example, HTTP request, email send, data transform).
• Operation: One execution of a module on a specific bundle of data.

Errors can happen at the module level (one operation fails) or at the route level (an error stops a whole route). Make.com gives you controls at both levels to decide what should happen after an error is detected.

Where to configure Make.com error handling

Error-handling settings in make.com are configured inside the scenario editor. You usually configure them on routes, and sometimes directly on modules.

1. Open your scenario in the editor.
2. Identify the route or module where you want to handle errors.
3. Open the error-handling options from the route line or module settings panel.

The exact controls may vary by module type, but the main principles and outcomes are consistent across the platform.

Default error behavior in Make.com

By default, make.com will stop processing a route when a module reports a critical error. This protects your data, but it can also pause important automations unexpectedly. The default behavior usually includes:

• Logging the error in scenario run history.
• Marking the affected operation as failed.
• Stopping downstream modules on the same route.

You can override this default by defining a different strategy for the affected route or module.

Configuring route-level error handling in Make.com

Route-level settings answer the question: “What should the scenario do with the rest of this route when an error occurs on any module in this path?” In make.com, you typically have several strategies to choose from.

1. Ignore and continue (use with caution)

This strategy tells make.com to continue processing the next module on the route even if a previous module fails.

Use cases:

• Non-critical logging or analytics steps.
• Optional notification modules where failure is acceptable.

Risks:

• Downstream modules might receive incomplete or invalid data.
• Important errors might be missed if you do not also set up notifications.

2. Rollback or stop the route

This strategy ensures that, when a critical error occurs, make.com stops the affected route and prevents further processing.

Use cases:

• Financial, billing, or accounting workflows.
• Inventory or order management scenarios.
• Any process where partial completion would corrupt data.

Behavior:

• The scenario halts processing on that route.
• The failed operation is logged for review.
• Other routes in the same scenario may continue if they are independent.

3. Automatic retries in Make.com

Many errors are temporary, such as network glitches or brief downtime on an external API. For these, make.com allows you to configure retries so the module can run again before being marked as failed.

Typical settings:

• Number of retry attempts.
• Delay between attempts.
• Optional backoff strategy (for example, increasing delay).

Recommended uses:

• HTTP modules calling third-party APIs.
• Database connections prone to occasional timeouts.
• Email senders impacted by rate limits.

Module-level error handling in Make.com

While route-level choices control the overall flow, module-level options help you decide how a single step should behave when it encounters a specific problem. Depending on the module type, make.com may offer options such as:

• Treating some non-200 HTTP status codes as success.
• Skipping particular records that fail validation.
• Mapping error messages into output fields so you can handle them later.

Module-level settings are valuable when only certain errors should interrupt the scenario, while others should be captured and processed as data.

Designing error handling flows in Make.com

Beyond basic settings, you can design dedicated subflows that branch on errors and apply specific recovery actions.

Use routers to branch on success vs. error

Many make.com modules output status information that you can evaluate in a router.

1. Connect a router after a module that may fail.
2. Create one route for successful operations (for example, status code 200–299).
3. Create another route for errors (for example, status code 400+ or error flag equals true).

This lets you separate business logic from error handling. Successful paths can continue, while error paths can log details, send alerts, or trigger compensating actions.

Send notifications on errors

To prevent silent failures, build an error-notification branch in make.com that activates whenever a route encounters a problem.

Common notification modules include:

• Email to an operations or support team.
• Message to a Slack or Microsoft Teams channel.
• Webhook to a monitoring or incident system.

Include key details in the notification, such as scenario name, module name, timestamp, and error message, so the right person can act quickly.

Log errors for later analysis

Good error handling in make.com also means creating an audit trail. In your error branch, you can:

• Write error entries to a Google Sheet, database table, or spreadsheet module.
• Store payloads and error responses in a storage module.
• Include correlation IDs to match logs to source systems.

This makes it easier to spot recurring failures and improve the robustness of your automations.

Testing error handling in Make.com scenarios

After configuring behavior, you should test how make.com responds to real-world failure conditions.

1. Run the scenario in manual or debug mode.
2. Trigger inputs that you know will cause an error (for example, invalid credentials, invalid data types, or unreachable endpoint URLs).
3. Verify that the configured route-level and module-level settings behave as expected.
4. Confirm that logs, notifications, and retries are produced exactly once per error.

Repeat these tests whenever you significantly change a scenario, especially before putting a business-critical automation into production.

Best practices for Make.com error handling

The following guidelines help keep your make.com scenarios stable and easier to maintain over time.

• Fail fast on critical data: Use stop or rollback strategies where inconsistent records would cause downstream problems.
• Use retries for transient issues only: Avoid retrying errors that are clearly permanent, such as invalid credentials.
• Separate error logic: Route errors into dedicated branches for logging and notifications, rather than mixing them into the main logic.
• Document expectations: Add comments or naming conventions to routes so other users understand how errors are handled.
• Review logs regularly: Use your log storage or scenario history to identify recurring failure patterns.

Learn more about Make.com error handling

For the most detailed, current reference on specific modules and advanced options, see the official error-handling documentation at Make.com Help Center. It explains module-specific behavior and any recent changes to the platform.

If you need tailored consulting or want to design a robust automation architecture, you can also explore specialist services from Consultevo, which focuses on automation and integration solutions.

By setting clear strategies at both route and module levels, and by testing how your configurations behave under failure conditions, you can ensure that make.com scenarios remain reliable, observable, and easy to troubleshoot as they grow in complexity.

Need Help With Make.com?

If you want expert help building, automating, or scaling your Make scenarios, work with ConsultEvo — certified workflow and automation specialists.

Get Help