Switch Node for Multi-Path Routing

Hello! Welcome back to our n8n course.

In the last lesson, we explored the If node, which gave us the power to create binary (true/false) branches in our workflows. This is perfect for simple yes/no decisions.

However, many real-world processes aren't that simple. Think about routing a support ticket based on its category (Billing, Tech Support, Sales) or processing an order based on its status (Pending, Shipped, Delivered). Chaining multiple If nodes for this would be cumbersome and hard to maintain.

This is where the Switch node comes in. In this lesson, we will learn how to use the Switch node for clean, efficient multi-path routing. For you as a developer, this is the visual equivalent of a switch statement, providing a much more elegant solution than a long chain of if-else if-else blocks for handling multiple distinct conditions.

1. The Power of the Switch Node: Clean and Maintainable Logic

When you have more than two possible outcomes, using a series of If nodes creates what can be called an "IF Chain Nightmare." It's hard to read, difficult to modify, and prone to errors. The Switch node elegantly solves this.

To understand this difference in-depth, I highly recommend reading the first part of the following Reddit post. It's written from a developer's perspective and perfectly articulates the value of the Switch node.

As the post highlights, the Switch node's superiority comes down to:

• Clarity: All routing rules are visible in a single node.
• Maintainability: Adding a new category or status is as simple as adding one new rule, not rewiring multiple nodes.
• Real-world alignment: It naturally models business logic that involves multiple states or types (e.g., customer tiers, order statuses, priority levels).

2. Configuring the Switch Node: Rules, Outputs, and Fallbacks

Let's walk through how to set up a Switch node. The most common configuration is the Rules mode, where you define a list of conditions, each corresponding to an output path.

This video provides a great hands-on demonstration of setting up rules, renaming outputs for clarity, and handling items that don't match any rule.

Key configuration steps are:

1. Data Field: Select the input data you want to evaluate (e.g., {{ $json.priority }}).
2. Add Routing Rule: For each path you want to create, add a rule with a condition (e.g., priority equals High).
3. Rename Output: Give each output a descriptive name (e.g., "High Priority"). This name will appear on the node's output port.
4. Set Fallback Output: Designate one rule as the fallback. This path will be taken if no other conditions are met. It's a crucial best practice to prevent items from being unexpectedly lost.

3. Rule Ordering and Building Out Branches

One critical aspect of the Switch node is that rules are evaluated from top to bottom. The first rule that evaluates to true "wins," and the item is sent to that output. Any subsequent rules are ignored for that item. Therefore, you should always place your most specific rules first.

This next video demonstrates a complete workflow build, reinforcing the setup and paying special attention to rule evaluation and the default case.

Best Practice Summary:

• Order Matters: Put specific rules (e.g., budget > 5000) before general ones (budget > 1000).
• Always Have a Default: Use a fallback or a final, always-true rule to handle unexpected values and prevent errors.
• Name Your Outputs: output 0, output 1 are meaningless. Shipped, Delivered, Cancelled are self-documenting.

4. A Glimpse into Advanced Routing

The Switch node is incredibly powerful, especially when combined with other n8n features. Your developer background will help you appreciate these advanced patterns.

• Expression Mode: Instead of UI-based rules, you can switch to Expression mode. This lets you input a value (e.g., {{ $json.priority }}) and then define case values for each output, much like a traditional switch statement.
• Programmatic Routing: The true power comes when another node programmatically generates the value that the Switch node evaluates.

This is a common pattern in AI workflows. For example, a "master" AI agent could analyze a user's request and output a structured JSON object telling the workflow which "specialist" agent to route the request to.

This pattern—where one node creates a "routing key" and the Switch node acts on it—is a cornerstone of building sophisticated, modular automations.

Conclusion

Today you've added a crucial tool to your n8n toolkit. You've seen how the Switch node is the superior choice for handling complex, multi-path logic, keeping your workflows clean, readable, and easy to maintain.

Key Takeaways:

• Use the Switch node for decisions with more than two possible outcomes. It's far cleaner than nested If nodes.
• Configure the node using Rules, giving each path a descriptive Output Name.
• Rule order is critical: More specific rules should always come before more general ones.
• Always define a Fallback Output to gracefully handle unexpected data.
• The Switch node enables powerful patterns like programmatic routing, where one node's output dynamically controls the workflow's direction.

In both the If and Switch nodes, we've seen how expressions like {{ $json.field }} are used to access data. But you can do much more than just access data. In our next lesson, we'll dive into the Expression Editor and learn how to write basic JavaScript to manipulate strings, numbers, and dates, unlocking a new level of dynamic control within your nodes.