Pausing Workflows with the Wait Node

Hello! Welcome back to our n8n course.

In the last lesson, we mastered a powerful pattern for handling complex, hierarchical data using sub-workflows to create nested loops. We focused on controlling what data gets processed in what order. Today, we'll shift our focus to controlling when that processing happens.

This lesson addresses the learning outcome: Use the Wait node to pause a workflow for a fixed duration. This is a fundamental capability for building robust automations that need to interact with the real world, where systems aren't always instantaneous. You'll learn how to introduce deliberate pauses into your workflows, a crucial technique for managing API rate limits, waiting for slow external services, or simply pacing an automation.

1. Understanding the Wait Node

In programming, you often use a sleep() or delay() function to pause execution. The Wait node is n8n's equivalent, but with some powerful features tailored for long-running automations.

At its core, the Wait node pauses a workflow's execution. When a workflow hits a Wait node, n8n can offload the execution data to your database, freeing up system resources. When the wait condition is met, it reloads the data and continues the workflow right where it left off.

To get started, let's look at the official documentation.

As you saw, the Wait node can resume based on several conditions. Today, we're focusing on After Time Interval, which is the most direct way to pause for a fixed duration.

A key architectural detail, especially relevant given your software development background, is how n8n handles the execution state during the wait.

This distinction is critical:

• Short waits (< 65s): The execution remains in memory. This is efficient for brief pauses, like rate limiting, as it avoids database read/write overhead.
• Long waits (>= 65s): The execution is persisted to the database. This is essential for long-running workflows (e.g., waiting hours or days), as it ensures the workflow can survive server restarts.

When a workflow is in a waiting state, you can see it clearly in the n8n UI.

2. Hands-On: Adding a Timed Delay to a Workflow

Now, let's put this into practice. We'll build a simple workflow that uses a Wait node to pause execution for a short period based on a condition. This exercise will not only show you how to configure the Wait node but also how it integrates with other logic nodes like If.

We will follow an exercise from the n8n documentation that demonstrates this perfectly.

Building the Workflow

Let's walk through the key steps from the exercise:

1. Start with Data: Begin your workflow with a Manual Trigger (or the default Start node) connected to the Customer Datastore (n8n training) node. Configure it for the Get All People operation and to Return All. This will provide the sample data.
2. Manipulate Data: Add a Date & Time node to process the created date from the datastore. This step isn't strictly necessary for learning the Wait node, but it's good practice for data handling.
3. Add Conditional Logic: Connect an If node to check a condition (e.g., if the date is after a certain point). This will create two branches: true and false.
4. Implement the Wait: This is our focus. Drag a Wait node and connect it to the true output of the If node.
   • In the Wait node's parameters, set the Resume mode to After Time Interval.
   • Set the Wait Amount to 1.
   • Set the Wait Unit to Minutes.
5. Continue the Flow: Add an Edit Fields (Set) node after the Wait node to complete the true branch.
6. Execute and Observe: Run the workflow. You will see the items that meet the If condition flow to the Wait node. The workflow execution will then pause. The node will show a countdown timer. After one minute, the execution will automatically resume, and the items will proceed to the final Set node.

If you get stuck or want to verify your setup, you can import the complete workflow solution.

3. Common Use Cases for Fixed-Duration Waits

Pausing for a fixed duration is a common requirement in automation. Here are a few scenarios where this is invaluable:

• API Rate Limiting: A very common developer task. If an API allows only 60 requests per minute, you can place a Wait node (set to 1 second) inside a loop that processes your API calls. This ensures you don't exceed the limit. We'll explore looping patterns like this in more detail later.
• Waiting for Asynchronous Jobs: You might trigger an external service (e.g., a video rendering API or a report generation tool) that takes time to complete its job. You can use a Wait node to pause your workflow for a reasonable estimate of the job's duration before attempting to fetch the result.
• Simulating Human Behavior: In automations that interact with users, like chatbots, instant replies can feel robotic. Adding a 1-2 second Wait before a response can simulate "typing" and improve the user experience.
• Ensuring Data Propagation: Sometimes, after writing data to one system (e.g., a database), it might take a few moments for that data to become available in a connected system due to replication lag. A short Wait can prevent race conditions where your workflow tries to read data that isn't there yet.

Conclusion

In this lesson, you've learned how to use one of n8n's essential flow control tools. By mastering the Wait node for fixed-duration pauses, you can build more reliable and sophisticated workflows that can gracefully handle real-world timing constraints.

Key Takeaways:

• The Wait node pauses a workflow's execution.
• The After Time Interval mode is used to wait for a specific duration (e.g., seconds, minutes, days).
• n8n intelligently manages system resources by keeping short waits in memory and offloading long waits to the database, ensuring resilience.
• Fixed-duration waits are crucial for tasks like API rate limiting, handling asynchronous jobs, and improving user experience.

In our next lesson, we will explore a more dynamic and interactive use of this node. You will learn how to implement a manual approval step using the Wait node with a webhook resume URL. This will unlock the ability to build workflows that pause indefinitely, waiting for external human or system input before continuing.