n8n Wait Node: Resume a Paused Workflow via Webhook (resumeUrl)
By Abhishek Patoliya · 2026-08-16
An approval step that might take five minutes or might take two days can't be built as a workflow that just sits there blocking — that ties up execution capacity for however long the wait turns out to be, and most execution environments aren't designed for that. The Wait node, specifically its webhook-resume mode, solves this by suspending the workflow's state entirely until an external event — a click on an approval link — sends a webhook that resumes it exactly where it left off.
How the Wait Node's Webhook Resume Actually Works
When a workflow hits a Wait node configured to resume on a webhook call, n8n pauses that execution and generates a unique resume URL tied to it. The workflow's state — everything computed up to that point — is persisted, not held in active memory waiting. Send that resume URL to whoever needs to approve (via email, Slack, wherever makes sense), and when they visit it or a system calls it, the workflow picks back up from exactly the Wait node, with any data included in that webhook call available to the rest of the workflow.
// Workflow shape
// 1. Prepare approval request (build a summary of what's being approved)
// 2. Send notification with a link to the Wait node's resume webhook URL
// 3. Wait node (mode: "Webhook", timeout: 48 hours)
// 4. [Continues here once resumed] — check the data the webhook call included
// 5. Branch based on approve/reject
Building the Actual Approval Link
The resume URL alone just resumes the workflow — it doesn't inherently carry an approve-or-reject decision unless you build that in. A simple approach: generate two links (approve and reject), each pointing at the same resume webhook but with a different query parameter or path, and read that parameter once the workflow resumes to determine which branch to take.
// Building the two links to include in a notification email/Slack message
const resumeUrl = $json.waitNodeResumeUrl; // provided by the Wait node's output
const approveLink = `${resumeUrl}?decision=approve`;
const rejectLink = `${resumeUrl}?decision=reject`;
// After the Wait node resumes, read the decision
const decision = $json.query?.decision ?? "no-response";
Setting a Timeout So the Workflow Doesn't Wait Forever
Configure the Wait node's timeout to a maximum reasonable wait — 24 to 72 hours is typical for a business approval, shorter for anything time-sensitive. If no webhook call arrives before the timeout, n8n resumes the workflow anyway, routing through the same downstream logic with no decision data present. Build an explicit fallback path for this case — escalate to someone else, apply a default action, or flag the item for manual follow-up — rather than letting an un-approved item silently proceed as if it had been approved, which is a common and costly oversight in approval flow design.
Handling Multiple Potential Approvers
For an approval that any one of several people can grant — not requiring all of them — send the same resume link to multiple recipients and handle the case where more than one person responds. Since only the first resume actually matters (the workflow already continued after that), build the downstream logic to tolerate a second webhook call arriving after the workflow has already resumed: check whether the execution is still in a waiting state before acting on the decision, and respond gracefully (a simple "already handled" message) rather than erroring on a call to an execution that's no longer paused.
Why This Beats a Polling-Based Alternative
An alternative approach — a scheduled workflow that polls a table every few minutes checking for a pending approval's status — works, but it's both slower to react (bounded by the poll interval) and noisier (repeated executions checking nothing has changed most of the time). Webhook resume reacts the instant the approval happens and consumes no execution capacity while genuinely waiting, which is a meaningfully better fit for anything where the response could plausibly arrive within minutes and you don't want to build in artificial polling latency.
Logging Approval Outcomes for Later Review
Record every approval decision — who, when, what was approved, how long the wait actually took — in a durable log separate from the workflow execution itself. Execution history in n8n is useful for debugging but isn't necessarily the right place to answer "who approved this invoice from three months ago" months later; a dedicated approvals log, queryable independently, is worth the small extra step of writing to it explicitly as part of the resume logic.
Handling a Rejected or Escalated Approval
Don't design the workflow around only the approve path — a reject decision, and the timeout fallback, both need their own explicit branches with real downstream logic, not just an implicit "everything that isn't approve is an error." A rejected invoice needs to notify whoever submitted it, with a reason if one was captured. A timed-out approval needs a clear escalation path, not a silent stop. Map out all three outcomes — approve, reject, timeout — before building the workflow, rather than building the approve path first and treating the other two as an afterthought once the happy path works.
Chaining Multiple Sequential Approvals
Some processes need more than one approval in sequence — a manager approves, then finance approves the same request. Each step is its own Wait node with its own resume webhook, chained one after another, with the output of one approval step feeding into the next as context (so the second approver can see what the first one decided, not just the original request in isolation). Keep each step's own timeout independent, since different approvers may have very different realistic response times, and a single shared timeout across the whole chain tends to either be too short for the slower step or too long for the faster one.
Securing the Resume URL
A resume webhook URL is, in effect, a bearer token — anyone with the link can trigger the resume, including its approve/reject decision. For approvals with real consequences (financial, access-granting), don't rely solely on the URL's obscurity as security. Where the underlying action matters enough, add a secondary check in the resume logic itself — confirming the requester's identity via an authenticated link rather than a bare URL, or requiring a follow-up confirmation step — rather than treating "the link isn't publicly guessable" as sufficient protection on its own for anything with real stakes attached.
For lower-stakes internal approvals, the URL's obscurity is often an acceptable level of protection, but make that judgment deliberately based on what the approval actually authorizes, not by default for every Wait-node-based flow regardless of what's on the other side of the decision. The cost of adding a stronger check is small relative to the cost of a forged or accidentally-forwarded approval link being used for something consequential. When in doubt, treat the higher-security option as the safer default — assuming a flow is genuinely low-stakes without actually checking what it authorizes is the kind of shortcut that looks harmless right up until the one time it isn't, and by then it's too late to add the check retroactively to a decision that has already been made and quietly acted on already by someone else entirely.
Written by Abhishek Patoliya, Senior n8n Developer & Automation Architect, Surat, India. Verified n8n Creator.