Routing and timing blocks

These blocks decide where a message goes and when. Blocks that wait or hold messages keep them durably: a restart of the platform does not drop them. Unless a key is set, blocks that remember per key keep one memory per device (the message’s originator). Each block keeps at most 10,000 keys and holds at most 16 MiB of messages.

Switch

Routes a message by the value of one property. Each rule has its own output.

Setting	Meaning	Default	Values
property	The value the rules test	msg.payload	a path
rules	One row and one output each: op, value (and value2 for between), optional Name	none	up to 16 rules
stop_first	Send only to the first matching rule	on	on, off

Outputs: o0 … o15 (one per rule, labelled with the rule’s Name if set), else (shown as “otherwise”), error. Operators are those of Compare, plus between (from value to value2, both included) and expr (the rule’s own expression is true). With stop_first off, every matching rule gets the message.

Gate

Lets messages through while open, holds or drops them while closed.

Setting	Meaning	Default	Values
initial	State when the flow starts	open	open, closed
control_topic	Topic of control messages; empty = none	gate	up to 64 characters
condition	Optional expression: open only while true	empty	an expression
closed	A message while closed	drop	drop, queue
max_queue	Messages kept when queueing	32	up to 1,000

Control messages have msg.topic equal to the control topic and msg.payload open (or true, 1, on), close (or false, 0, off), toggle or status; they are not passed on. Outputs: out, dropped (dropped while closed, or pushed out of a full queue), error. Example condition for working hours: number(fmt_time(now(), "%H")) >= 8 && number(fmt_time(now(), "%H")) < 18.

All of

Waits until messages with different keys (by default different topics) have all arrived within a window, then sends one message holding all their payloads.

Setting	Meaning	Default	Values
window_ms	All messages must be younger than this; 0 = no limit	10 s	0 to 24 h
key	Where the key is read from	msg.topic	a path
min_inputs	How many different keys are needed	2	2 to 16

Output out: the completing message with msg.payload = { key: payload, … }. Only the completing message goes out. What it collects is kept per device by default (group_by: originator, or flow).

Any of

Passes every message; optionally drops repeats of a key.

Setting	Meaning	Default	Values
dedup_ms	Drop a message whose key passed less than this ago; 0 = pass all	0	0 to 24 h
key	The key for the repeat check	msg.topic	a path

Not

Replaces msg.payload with its logical opposite, true or false. false, null, 0, "" and not-a-number become true; everything else (including "0", "false", [], {}) becomes false. No settings.

Split

One message per part of msg.payload: per array element, per object key, per line of text, or per fixed-size chunk.

Setting	Meaning	Default	Values
mode	auto (element, key or delimiter) or length (chunks)	auto	auto, length
delimiter	Where text is cut; \n new line, \t tab	\n	up to 16 characters
length	Chunk size in elements or characters	1	1 to 65,536

Each part carries msg.parts (id, index, count, type, key …) for Join. Error queue_full above 10,000 parts.

Join

Collects messages into one.

Setting	Meaning	Default	Values
mode	auto rebuilds what Split cut; manual builds from any messages	auto	auto, manual
build	What to build (manual)	array	array, object, string
joiner	Between text pieces	\n	up to 16 characters
key	Object key of each message	msg.topic	a path
count	Send after this many messages; 0 = no count	0	0 to 10,000
timeout_ms	Send what has arrived this long after the first message; 0 = wait	0	0 to 24 h

msg.complete (any value) sends a manual group at once. Set count, timeout_ms or msg.complete in manual mode, or the group only goes out at the 10,000-message cap.

Sort

Sorts a list (array mode: property, optional field) or the messages of a group made by Split or Batch (messages mode: key, timeout_ms). Settings: order asc/desc, numeric on/off (without it, "10" sorts before "9"). Error queue_full over 10,000 elements.

Batch

Sends messages on in groups.

Setting	Meaning	Default	Values
mode	By number or by time	count	count, interval
count	Messages in a group	10	1 to 10,000
overlap	Messages of the last group sent again with the next	0	0 to count − 1
interval_ms	Time from the first waiting message until the group goes out	1 s	1 ms to 24 h

Each message of a group gets msg.parts; a Join in auto mode then makes one list.

Delay

Holds each message, then sends it on unchanged.

Setting	Meaning	Default	Values
ms	Wait	1 s	0 to 7 days
ms2	Upper end of a random wait	empty	0 to 7 days
from_msg	Take the wait from msg.delay	off	on, off
max_pending	Messages waiting at once	1,000	1 to 100,000
on_new	queue: each waits its own time; restart: a new message drops the waiting ones of its key	queue	queue, restart
key	Key for restart	msg.originator	a path

msg.reset = true drops every waiting message. Error queue_full when max_pending is reached.

Debounce

One message per burst.

Setting	Meaning	Default	Values
ms	Quiet time that ends a burst	500 ms	0 to 24 h
edge	trailing: the last message after the quiet time; leading: the first at once	trailing	trailing, leading
key	Each key debounced on its own	msg.originator	a path

Deduplicate

One message per period and key, however many arrive.

Setting	Meaning	Default	Values
strategy	first, last, or all (one message whose payload lists every { payload, metadata })	first	first, last, all
window_ms (Period)	Starts with the first message of a key	60 s	1 s to 24 h
key	One pack per value	msg.originator	a path
time	message (the reading’s own time, from ts_path or the record time) or arrival	message	message, arrival
ts_path	Where the reading’s time is (time = message)	the record time	a path
max_pending	Messages kept per key for all	100	1 to 1,000
msg_type	Message type of the all result	the first message’s type	up to 64 characters

The result carries msg.metadata.dedup with count, start and end. With Time message, a flushed backlog gives one result per period of device time.

Rate limit

At most n messages per period and key.

Setting	Meaning	Default	Values
n	Messages per period	1	1 to 10,000
per_ms	The sliding period	1 s	1 ms to 24 h
mode	Over the limit: drop, latest (keep only the newest), queue	drop	drop, latest, queue
max_queue	Messages waiting per key	32	1 to 1,000
key	Each key has its own limit	msg.originator	a path

Outputs: out, dropped. Use it in front of an SMS, mail or outside call.

Only changes

Passes a message only when its value changed since the last one passed.

Setting	Meaning	Default	Values
property	The value	msg.payload	a path
mode	change, deadband (by at least value), deadband_pct (by at least value % of the last value)	change
value	The dead band	0	0 or more
key	Each key has its own last value	msg.originator	a path
first	Let the first value of a key pass	on	on, off

The new value is compared with the last value that passed, so slow drift is reported once it adds up.

Trigger

Sends a first message, waits, then sends a second.

Setting	Meaning	Default	Values
first	Sent at once: the message itself, nothing, or a value for msg.payload	the message
then	Sent after the wait: nothing, the message, or a value	nothing
ms	Wait	1 s	0 to 7 days
extend	A new message while waiting restarts the wait	off	on, off
key	Each key has its own wait	msg.originator	a path

msg.reset = true cancels the wait of that key.

Detach

The rest of the branch runs separately, so the device’s next message does not wait for it. Use it before a slow branch. After it, message order is not guaranteed. No settings.

Link call

Sends the message to a Link in (or with flow:<slug>, to another flow’s Flow input) and waits for the answer from a Link out in mode return.

Setting	Meaning	Default	Values
target	The Link in name	required
timeout_ms	Wait for the answer	30 s	1 ms to 1 h
returns	Named returns of the target; each becomes an output	none

Outputs: out (the answer), one per named return, timeout (no answer in time; the original message), error (invalid_value no such link, queue_full, unknown_return, loop). Calls nest at most 16 deep; a call into its own call stack fails with loop.