Skip to main content
The Error Shield node protects your workflows by catching and handling errors gracefully. Instead of letting your entire workflow crash when something goes wrong, Error Shield catches the error and lets you decide what happens next.

​
Overview

Think of Error Shield as a safety net for risky operations. When you wrap a node with Error Shield, it creates two possible outcomes: a success path for data that processes correctly, and an error path for handling failures.

Prevent Workflow Crashes

Catch errors before they stop your entire automation

Handle Failures Gracefully

Define custom logic for errors instead of generic failure messages

Track Failed Items

Identify which specific inputs caused problems in Loop Mode

Continue Processing

Keep your workflow running even when some items fail

​
How It Works

Error Shield wraps around other nodes and monitors their execution. When the wrapped node processes data:
  • Success: Output flows to the Success Path
  • Failure: Output flows to the Error Path (original input if “Pass Inputs Through” is enabled)
Error Shield with Pass Inputs Through enabled, showing both success and error paths reconnecting via Join Paths
This image shows how “Pass Inputs Through” sends the original input to the error path, and how Join Paths merges both success and error paths back together to continue the workflow. Try it yourself: View and clone this example flow

​
Configuration

The node you want to protect from errors. Simply drag a node inside the Error Shield container to wrap it.
When enabled, the Error Path receives the original input that caused the error instead of an error message. This is essential when you need to:
  • Log which specific items failed
  • Retry failed items later
  • Format fallback data based on the original input
Example: If scraping “https://broken-site.com” fails, the Error Path receives “https://broken-site.com” instead of just an error message.

​
Outputs

  • Success Path
  • Error Path
Contains data that was successfully processed by the wrapped node.Single Item: The processed resultLoop Mode: A list containing only the successfully processed items

​
Critical Behavior in Loop Mode

Understanding how Error Shield behaves in Loop Mode is essential for building reliable workflows.

​
Node NOT in Loop Mode

When the wrapped node is not in Loop Mode, Error Shield processes a single item at a time: 
Website Scraper (Normal Mode) wrapped in Error Shield
Input: "https://example.com"

If successful:
✅ Success Path: Scraped content
❌ Error Path: Not triggered

If failed:
❌ Success Path: Not triggered (workflow stops here)
✅ Error Path: "https://example.com" (if Pass Inputs Through enabled)
Without Loop Mode, a single failure stops the workflow at the Error Shield. To continue processing after an error, you must use Join Paths to reconnect the error path back into your workflow.
Error Shield in normal mode showing workflow stopping at error

​
Node in Loop Mode

When the wrapped node is in Loop Mode, Error Shield processes each item individually and continues even when some items fail: 
Website Scraper (Loop Mode) wrapped in Error Shield
Input: [
  "https://site1.com",
  "https://site2.com" (fails),
  "https://site3.com",
  "https://site4.com" (fails)
]

Results:
✅ Success Path: [site1 content, site3 content]
❌ Error Path: ["https://site2.com", "https://site4.com"]
Loop Mode automatically skips failed iterations. The Success Path contains only successful results, while the Error Path captures all failed inputs. The workflow continues processing remaining items even after failures.
Error Shield wrapping a node in Loop Mode showing successful and failed items

​
Working with Join Paths

To continue your workflow after handling errors, use the Join Paths node to merge success and error paths back together.

​
Basic Pattern: Single Item Processing

When processing individual items (not in Loop Mode), you need Join Paths to continue the workflow after an error:
1

Enable Pass Inputs Through

Turn on “Pass Inputs Through” in Error Shield to access the original input on the error path
2

Format Fallback Data

On the error path, create fallback data or a message indicating the failureExample: Use Combine Text to create “Failed to process: [original input]”
3

Join the Paths

Connect both success and error paths to a Join Paths node to reunite them
4

Continue Workflow

After Join Paths, continue with the rest of your workflow logic
Workflow Diagram: Error Shield Example with Join Paths: View and clone this example flow
Without Join Paths, the error path would be a dead end, and your workflow would stop when an error occurs.

​
Real-World Examples

Scenario: Scrape product information from multiple websites, some of which may be down or blocked.Setup:
  1. List of product URLs → Website Scraper (Loop Mode) wrapped in Error Shield
  2. Success Path → Extract product details → Format as JSON
  3. Error Path (Pass Inputs Through enabled) → Log failed URLs to sheet
  4. Join Paths → Send summary email with results and failed URLs
Outcome: Successfully scrapes available sites while documenting failures for manual review
Scenario: Process invoices from various sources, providing default values when extraction fails.Setup:
  1. Invoice PDF → Extract data (wrapped in Error Shield)
  2. Success Path → Format extracted data
  3. Error Path → Create record with “Manual review required” status
  4. Join Paths → Save to database
Outcome: All invoices are logged, with failed extractions flagged for manual processing
Scenario: Fetch user data from external API that occasionally times out.Setup:
  1. User ID → API call (wrapped in Error Shield)
  2. Success Path → Process user data
  3. Error Path → Wait 30 seconds → Retry API call (wrapped in second Error Shield)
  4. Second Success Path → Process user data
  5. Second Error Path → Log failure and notify admin
  6. Join Paths → Continue workflow
Outcome: Automatic retry for transient failures, with notifications only for persistent errors
Scenario: Send personalized emails to customer list, tracking delivery failures.Setup:
  1. Customer list → Send Email node (Loop Mode) wrapped in Error Shield
  2. Success Path → Log successful sends to “Delivered” sheet
  3. Error Path (Pass Inputs Through) → Log failed emails to “Bounced” sheet with customer details
  4. Join Paths → Generate summary report
Outcome: Emails sent to all valid addresses, with bounce list for cleaning up customer database

​
Common Use Cases

Web Scraping

Handle website timeouts, blocks, or invalid URLs without stopping your entire scraping job

File Processing

Continue processing a batch of files even if some are corrupted or in unexpected formats

API Integrations

Manage rate limits, timeouts, and invalid responses from external services

Data Validation

Process valid records while capturing and handling invalid ones separately

​
Setup Guide

1

Add Error Shield to Canvas

Drag the Error Shield node from the Flow Basics section onto your workflow canvas
2

Wrap Your Node

Place the node you want to protect inside the Error Shield container. The node will now be protected from errors.
3

Enable Pass Inputs Through (Optional)

Toggle this setting if you need to access the original input that caused errors. This is essential for:
  • Logging which specific items failed
  • Creating fallback data based on original input
  • Retrying failed operations
4

Connect Success Path

Wire the Success Path output to the next step in your workflow that should receive successfully processed data
5

Handle Error Path

Connect the Error Path to error handling logic:
  • Log failures to a database or sheet
  • Send notification alerts
  • Create fallback data
  • Format error messages for users
6

Use Join Paths (If Needed)

If both paths need to continue through the same workflow logic, add a Join Paths node to merge them back together
7

Test Both Paths

Run your workflow with both valid and invalid inputs to ensure both success and error paths work as expected

​
Best Practices

Wrap any node that might fail in Error Shield:
  • External API calls
  • Web scraping
  • File operations
  • Database queries
  • Email sending
  • Data transformations on uncertain input formats
When processing lists, always enable “Pass Inputs Through” so you can track which specific items failed and potentially retry them later.
If the wrapped node is NOT in Loop Mode, use Join Paths to allow your workflow to continue after error handling. Without it, errors create dead ends in your workflow.
For complex error handling in Loop Mode, wrap your entire processing logic in a subflow, then wrap the subflow in Error Shield. This keeps related data together and prevents list size mismatches.Learn more about Subflows with Error Shield

​
Additional Resources

Video Tutorial

Watch a step-by-step guide to using Error Shield

Join Paths Documentation

Learn how to merge conditional paths

Loop Mode Guide

Understand how Loop Mode processes lists

List Size Mismatch Errors

Fix common errors with Error Shield and Loop Mode