The Join Paths node allows multiple conditional paths in your workflow to reconnect into a single path. When you use If-Else or Error Shield nodes, Join Paths lets you continue your workflow with the executed path rather than requiring duplicate nodes for each condition.

​
Node Structure

​
Required Inputs

  • Input 1: First potential execution path (any data type)
  • Input 2: Second potential execution path (any data type)

​
Optional Inputs

  • Additional Input Paths: Add more inputs for complex branching scenarios

​
Output

  • Continuation Path: Data from the executed branch (maintains original data type)

​
Why Use Join Paths?

Without Join Paths, conditional workflows face two major issues:

  1. Path pruning after branching completely stops the non-executed path
  2. Forces creation of duplicate nodes for each potential path

​
Key Benefits

  • Eliminate Duplicate Nodes: No need to repeat the same nodes in each conditional branch
  • Cleaner Workflows: Maintain single processing paths after conditions
  • Better Maintenance: Update one set of nodes instead of multiple copies
  • Resource Efficiency: Reduce redundant operations

​
When to Use

Use Join Paths whenever your flow:

  • Contains If-Else conditional branching
  • Uses Error Shield for error handling
  • Has multiple processing paths that need to continue through the same steps
  • Requires different handling based on input types or conditions

​
Key Considerations

  1. Only one input path is active during runtime
  2. Non-executed paths are pruned
  3. Original data type is preserved
  4. No data merging occurs - it continues the active path
  5. Loop mode is not supported

​
Why No Loop Mode?

Join Paths is designed to handle single-path execution where only one branch is active at a time. Loop mode, which processes multiple items concurrently, would create ambiguity about which path’s data should continue when multiple branches are active simultaneously. This limitation ensures predictable and reliable flow execution.

​
Working with Lists and Loops

If you need to process multiple items with conditional logic:

  1. Create a subflow that contains your conditional logic and Join Paths node
  2. Test the subflow with a single input to ensure it works correctly
  3. In your main flow, use Loop Mode to iterate the subflow over your list of items

This approach allows you to maintain the benefits of Join Paths while still processing multiple items efficiently.

​
Example Flows

​
1. Document Source Handler

Scenario: Processing content from either Google Docs or websites

Try it yourself: View and clone this example flow

Input URL → If-Else (Is Google Doc?)
            ├─ Yes → Extract Google Doc Content →
            └─ No  → Scrape Website Content    → Join Paths → Summarize

What’s Happening:

  • Flow receives a URL input
  • If-Else checks if it’s a Google Doc link
  • Each path uses appropriate extraction method
  • Join Paths allows single summarization node
  • Without Join Paths, you’d need two separate summarize nodes

​
2. Multi-Source Content Processor

Scenario: Handling different document types (Google Docs, PDFs, websites)

Try it yourself: View and clone this example flow

Input URL → First If-Else (Is Doc?)
            ├─ Yes → Process Doc    →
            └─ No  → Second If-Else (Is PDF?)
                    ├─ Yes → Process PDF     → Join Paths (3 inputs) → Summarize  
                    └─ No  → Process Website →

What’s Happening:

  • Flow determines content type through multiple conditions
  • Three different processing paths based on file type
  • Join Paths consolidates all three potential paths
  • Single summarization node handles all content types
  • Eliminates need for three separate processing chains

​
3. Error-Protected Web Processing

Scenario: Web scraping with error handling and result logging

Try it yourself: View and clone this example flow

URL Input → Subflow wrapped in an Error Shield
            ├─ Success → Scrape Website → Summarize Content →
            └─ Error   → Create "Invalid URL" Message      → Join Paths → Write to Sheet

What’s Happening:

  • Error Shield protects the scraping operation
  • Success path processes and summarizes content
  • Error path creates an error message
  • Join Paths ensures sheet is updated in both cases
  • Single sheet-writing logic handles both outcomes

​
Step by Step Usage

  1. Add Join Paths node after your conditional branching
  2. Connect first potential path to Input 1
  3. Connect second potential path to Input 2
  4. Add more inputs if needed for additional paths
  5. Connect the output to your next node
  6. Test each conditional path to ensure proper flow

In summary, Join Paths is essential for building efficient workflows with conditional logic, eliminating the need for duplicate nodes while maintaining clean and manageable flows.

Error ShieldAsk AI