Request Plus: HTTP Request node with built-in Wait, Split Out and Filter (n8n-nodes-request-plus)

Hi everyone!

I built a community node called Request Plus — it’s an HTTP Request node with three things built in, so you don’t need extra nodes for common patterns:

  • Wait Prefix / Suffix – waits before and/or after each request. Every input item makes its own request, so no more Loop Over Items + Wait just to throttle calls.
  • Split Response – splits a list from the response into separate items, like Split Out.
  • Filter Response – keeps only the items that match your conditions (runs after the split).

Execution order per input item: wait prefix → request → wait suffix → split → filter


Fields

Section Field What it does
Request Method, URL, Authentication, Query, Headers, Body (JSON / Form Urlencoded / Raw) Same as the native HTTP Request
Wait Wait Prefix / Wait Suffix + Unit Wait before/after each request (ms, s or min)
Wait Skip Prefix on First / Skip Suffix on Last Don’t wait on the first/last item
Split Field to Split Out Path to the list, e.g. data.items. Empty = the response itself
Split Include Copies other response fields into each item (all, or selected ones like page, meta.total)
Split Destination Field Name Puts each item inside a field instead of at the root
Filter Conditions Field (e.g. status, customer.id, tags[0]) + operation + value
Filter Combine / Case Sensitive AND/OR, case sensitivity
Options Full Response, Never Error, Response Format, Timeout, Follow Redirects, SSL Same as the native HTTP Request

With Full Response enabled, the response becomes { body, headers, statusCode }, so paths start with body. (e.g. body.data.items).

Authentication uses n8n’s generic credentials: Basic Auth, Header Auth (Bearer, API key) and Query Auth.


Installation

Option 1 – Community Nodes (self-hosted): Settings → Community Nodes → Install → n8n-nodes-request-plus

Option 2 – Manual (Docker): build it and mount it in the custom nodes folder:

npm install
npm run build
services:
  n8n:
    image: n8nio/n8n
    volumes:
      - n8n_data:/home/node/.n8n
      - ./n8n-nodes-request-plus/dist:/home/node/.n8n/custom/n8n-nodes-request-plus

Then docker compose up -d --force-recreate n8n and search for Request Plus in the nodes panel.

Or copy into a running container:

docker cp dist/. <container-name>:/home/node/.n8n/custom/n8n-nodes-request-plus
docker restart <container-name>

Not included (yet)

Automatic pagination, binary file upload/download, multipart/form-data and OAuth2.

npm: n8n-nodes-request-plus

Feedback, bug reports and feature ideas are very welcome!

How do the longer waits behave in queue mode? For example, does a one-minute suffix keep the worker occupied, or persist the execution and resume later like the Wait node? That distinction would help when deciding whether to use this for a large batch.

Great question, and the distinction matters here.

Right now, the waits are in-process. The prefix and suffix are a plain sleep inside the node, so a one-minute suffix keeps the worker busy for that whole minute. Nothing is saved to the database and resumed later, the way the native Wait node does it. In queue mode that blocks a worker slot. For a large batch with long waits, that adds up quickly.

What I’d recommend today for large batches with long waits: use Request Plus without the suffix, inside a Loop Over Items, and put n8n’s native Wait node after it. For waits over ~65 seconds, the Wait node saves the execution and frees the worker. The prefix and suffix are best for short pauses like rate limiting (a few hundred ms up to a few seconds), where holding the worker doesn’t matter.

What I’m considering adding: a “Hand Off” mode. When the next wait is long, the node would send the remaining items to a separate output so you can connect them to a native Wait node and back into Request Plus. You’d keep the convenience of the node, and the long waits would free the worker. It isn’t available yet, but your question is a good reason to build it.

Thanks for raising it!

That makes the tradeoff clear. I’d put the worker-slot warning next to the minutes option in the docs, so people see it before setting a long delay. For Hand Off, a useful test would be: complete item A, hand off B and C, restart during the wait, then resume. Check that A isn’t sent again and that B and C keep their original IDs and order. For requests with side effects, I’d also document what happens if the request succeeds but execution stops before its completion is saved; that case needs a retry/idempotency plan as well as a timer.

Thanks, that’s really helpful.

Docs:agreed. I’ll move the worker-slot warning next to the Minutes option, so it shows up before someone sets a long delay.

Hand Off:your restart scenario is exactly the case it’s meant to solve, so I’ll use it as the acceptance test. The idea is that completed items (A) leave through the normal output right away, and the pending ones (B, C) go out through a separate output into the native Wait node, which persists the execution and frees the worker. Each pending item would carry its original ID and position, so B and C come back unchanged and in order, and A can’t be sent twice because it’s never part of the hand-off.

Side effects: good point. “Succeeded but not saved” can still cause a resend on resume, the same as with a retried HTTP Request node. So I’ll document Hand Off as at-least-once, not exactly-once. For endpoints with side effects, I’m thinking of an optional idempotency key per item (a header from an expression, e.g. the item ID), plus a note to check state before retrying when the API doesn’t support one.

I’ll post here once there’s something to test.

For the optional key, one boundary worth making explicit is ‘one logical operation’, rather than just ‘one item’. The same item might need a legitimate second update later, so its ID alone could accidentally suppress that update.

Generate the operation key before the first send, persist it with the pending item, and reuse it across retries/resumes. A genuinely new operation gets a new key. Also document that the receiving API must honor the key, including its retention window; sending a header alone does not make the request idempotent.

A useful acceptance pair would be: replay the same operation and payload → one side effect; submit a new operation for the same item → a second intended side effect. That would complement the restart test without implying exactly-once delivery.

Bundling wait and split operations directly inside the request node significantly simplifies high-volume pagination loops. In complex pipelines, having separate wait and filter nodes scattered across the canvas makes error tracking messy.

Adding exponential backoff handling for 429 status codes directly within the node configuration prevents downstream rate limits from breaking the entire batch execution.