How should I handle a workflow that takes about 20 hours to execute when the N8N starter plan only allows 5 minutes and the pro plan 40 minutes?
The execution time limit of 40 minutes versus your estimated 20‑hour run clearly doesn’t match. The simplest solution is to split the long‑running part into a sub‑workflow. Use the Execute Workflow node to call another workflow that handles the looping over items. Set up the sub‑workflow with a weight or delay to smooth out API errors and rate limits, and make sure you turn off the option to wait for the sub‑workflow to finish so the main flow continues instantly. This pattern is essentially the same as sending an HTTP request to your own N8N workflow and handling the response with webhooks. It works on both the Pro and even the Starter plan because the heavy lifting happens in the background sub‑workflow.
Sure. Let me walk you through the solution. Your current scenario loops over an input—say a thousand records—using a built‑in iterator and then feeds each record into an AI module that takes several seconds to run. At 5 seconds per execution, you’d hit the 45‑minute timeout after roughly 600 runs, which makes the whole process take a very long time. The fix is to split the scenario: instead of processing everything in one long loop, have the iterator immediately send each record to an external service via an HTTP webhook. The webhook executes almost instantly (around 0.001 seconds), so you can process millions of records within the same timeout window. In practice, you can create a small JSON array, iterate over it, and for each item make a webhook call that triggers the AI module on a separate scenario. This way the sender scenario finishes quickly, and the receiver scenario handles the AI work without ever hitting the timeout. You can also use Make’s sub‑scenario feature or a dedicated Make.com module, but webhooks are the simplest and most reliable method. Just ensure your Perplexity search and ChatGPT modules are placed in the receiving scenario, and you’ll avoid the timeout entirely.
From an automation perspective, the slowdown likely comes from variable timing in a module—often an AI component that searches the web or has non‑deterministic reasoning loops causing excessive calls, or an infinite recursive loop during list enrichment. I’d examine the fuzziest parts of the workflow and work backward. This shows up in AI‑based enrichment workflows using tools like Make.com or Integromat, where AI‑provider latencies (Anthropic, OpenAI) can push runtimes beyond 5, 10, or 15‑minute windows, leading to timeouts. I avoid letting workflows exceed those limits.
The issue is that you’re iterating over a very large number of modules with a time‑step between each call, which makes the flow take a long time per row. Instead of running everything in one long chain, split the work into two scenarios. First, use an array module to collect all the rows, then feed each row into a second scenario via a webhook. That second scenario runs one row at a time, so each iteration only executes the AI module (or any other heavy module) and then finishes before the next one starts. By processing one record per scenario you keep each run well under Make’s timeout limit (around 40‑45 minutes). You can also reduce the number of modules that require waiting (e.g., avoid unnecessary variable steps) and use the “run a scenario” module to orchestrate the two‑step flow. This approach brings the per‑row runtime down to a few seconds, allowing you to handle all 350 rows without hitting the timeout or exhausting your rate limits.
The weight (actually wait) node in Make simply pauses the scenario for a set amount of time; it isn’t a webhook. The webhook URL is generated at runtime and the scenario resumes when the webhook is called. You can define a callback URL in Appify so that when the Upwork actor finishes it calls that webhook and the flow continues. In the example Santi uses n8.pulsense.com/webhook as the callback. There’s also a newer Appify API endpoint that runs the actor synchronously and returns the data set items directly, eliminating the need for the wait‑node‑plus‑webhook pattern. Using that endpoint is the simpler, more reliable way to avoid delays or missed updates.