How can I combine multiple Telegram messages into one after a 15-second delay in n8n?

Below is one approach you can take to “buffer” incoming Telegram messages over a fixed delay (15 seconds in your case) and then merge them into one message:

1. Use the Telegram Trigger Node

Set up a Telegram Trigger node to listen for incoming messages. Each time a new message arrives, it will start or trigger the workflow.

2. Collect Messages During a Waiting Period

There are a couple of ways you might implement the 15‑second “collection window”:

• Option A – Using a Wait Node:
  After the Telegram Trigger, insert a Wait node (set to wait for 15 seconds). When the first message is received, wait for the delay and then continue. If additional messages are coming in quickly, you can design your workflow so that each new message “joins” the waiting queue. One common pattern is to run the workflow for the first message, delay, and then have subsequent messages merge into a common list (for example by writing to external storage or a Redis cache). Once the delay is over, fetch all buffered messages.

• Option B – Using a Code Node (or a custom aggregation mechanism):
  Alternatively, if your use case allows you to spawn a workflow that collects several items (for example through triggering multiple workflows with the same user identifier), you can use a Code node to merge the incoming data. In this approach, you might have a “buffering” mechanism (either a temporary database or a global variable if your setup allows it) that accumulates the messages from the same user for 15 seconds. Once the time window is reached, use a Code node to combine the text of all stored messages into a single string.

3. Combine the Message Content

Once you have collected the messages, use a Code node to concatenate them. For example, if you have an array of message objects (each with a property like message.text), you can write something like:

JSCopied
// Assume items is an array of messages collected during the wait period
// Each item has an object like { json: { text: "word" } }
const combinedText = items.map(item => item.json.text).join(" ");
return [{ json: { message: combinedText } }];

4. Send the Merged Message to the Next Step

After combining the messages, you can pass the merged content along to the next node in your workflow (such as another Telegram node to post the message, or any other communication node).

Considerations

• Message Deduplication and Order:
  Ensure that all messages coming from the same user (or conversation) are correctly grouped. You may need to add a condition (for instance, checking a user ID) so that only messages from the same user are aggregated together.

• Buffer State:
  If messages are arriving continuously, consider using an external store (like a database or in-memory cache) to accumulate messages over the defined time window. Once the window expires, retrieve and clear the buffer.

• Workflow Design Variations:
  Depending on your use case, you might either spawn a dedicated workflow per conversation or have one central workflow that handles buffering. In either case, ensure that the “wait” mechanism resets properly after processing a batch.

Using these nodes and some custom JavaScript to merge the text should allow you to achieve the behavior where several one-word messages are concatenated into a single message after a 15‑second delay.

This approach leverages built-in n8n nodes (such as Telegram Trigger, Wait, and Code nodes) and simple aggregation logic. You can further tweak the solution based on your specific needs (like handling multiple users concurrently, or using more advanced aggregation logic).