Nodes

A node is one step of a flow. Each node has a type (what it does), field values (its parameters), settings (retries, timeout, what to do on error) and one or more output dots (handles). An edge leaves from an output dot and lands on the next node, so a node with true and false dots branches the flow.

Mooflair ships 81 built-in nodes in 9 domains, and you can add your own script nodes.

In this section

Anatomy of a node

{
  "id": "collect",
  "type": "x/collect",
  "name": "Collect posts",
  "field": { "max": 20, "language": "id", "refreshAfter": 50 },
  "setting": { "retry": { "count": 0, "waitMs": 1000, "backoff": "fixed" }, "error": { "mode": "stop", "fallback": null, "break": { "count": 3, "waitMs": 600000 } }, "timeoutMs": 600000, "disabled": false, "item": { "isOnce": false, "isAlways": false, "batch": { "size": 0, "waitMs": 0 } } },
  "pin": null,
  "position": { "x": 900, "y": 0 },
  "note": "Keeps scrolling; refreshes every 50 posts"
}

An edge goes from an output dot to an input dot; a dot can have many edges (each gets the items):

{ "id": "e1", "source": { "nodeId": "collect", "handle": "next" }, "target": { "nodeId": "choose", "handle": "in" } }

Items

What travels along an edge is a list of items (like n8n), each { json } with its (a screenshot, a download) and a trail linking it to the items it came from. A trigger starts a run with one item. Most nodes run once per input item (run: "each"), their fields resolved against that item; Merge runs once with every item (run: "once"). A node returns its items, each on one of its dots; an empty list ends that branch. A node with several inputs (Merge's A and B) waits until each connected input has delivered. See .

Common settings

Every node has the same settings (Node details › Settings). A node definition can change the defaults, and so can a template.

Limit

Any node can have a limit (Node details › Settings › Limit): manual, its own windows (several at once: 15 an hour and 180 a day), or account, none of its own (the account's limit on posts, replies and quotes waits for a free slot instead, see ). With windows set, it gets one more output dot, limited.

1. Before the step runs, the engine checks its key against every window with mooflair (): limit.key, or empty for <node type>:<account id> (x/post:6ae4…, threads/reply:6ae4…), so each account has its own.
2. No slot left: the step doesn't run; the item leaves through limited with { "count": 1, "nextAt": "2026-10-30T15:00:00.000Z" }: nextAt is when every window has room again. A until {{ nodes.<id>.output.nextAt }} holds the run for the next slot, or a Wait in limit mode before the node waits until it may run at all (the posting templates do this, so nothing is written for a post that can't go).
3. It counts only once the step ran: a failure or a crash mid-step counts nothing. A rollback takes the count back. Two runs on the same key at the very same moment can both pass the check: it goes over once, and says so in the log.

Test runs only look: they never take a slot. Example: 𝕏 Post with limit.mode {{ option.pace.limit.mode }} and limit.window {{ option.pace.limit.window }}, a campaign setting its limit option to 1 per 3 hours, posts at most once every 3 hours; switched to Follow the account, only the account's own limit applies.

No repeats

With unique.isEnabled on, a node gets one more output dot, duplicate. Before the step runs, the engine asks mooflair () whether it would repeat itself:

1. Its unique.value (empty: its text field, the post, quote or reply it is about to send) is compared to what it already did: the last 1000 rows of unique.table, their unique.column (x/post/post › text for 𝕏 posts and quotes, threads/post/thread › post, x/collect/post and threads/collect/post › message for replies). The table keeps them as it does (per account, or per campaign group), so the history is everything the account already posted, from before this setting existed too.
2. Words in common over words in either (case, punctuation and links aside) at or above unique.similarity is the same: 0.8 catches a rewrite of one or two words, 0.9 suits short replies, 1 only the same words.
3. With unique.aiId (an AI key, {{ option.account.ai }}), when the words differ, the AI also reads the last 30 and answers whether the new one says the same thing in other words.
4. The same: the step doesn't run; the item leaves through duplicate with { "text": "…", "same": "<the one it matched>" }.

Nothing is recorded by this setting: the node's own row is the record, written only once it really posted, so a crash leaves nothing behind. Test runs compare with test rows. The templates turn it on with the No repeats option (on by default) and send duplicate where they go when there's nothing to post.

On error

commit, rollback and break end the whole run from wherever they are, a called flow included.

How a rollback knows what to undo: every run's token carries a journal id, and each table write or cap count through the saves its undo step (FlowJournal, kept 90 days). When the run ends with rollback, the engine hands the journal id back and mooflair runs those steps. A resumed run has a journal of its own, so a rollback undoes only that attempt's writes.

Raised defaults (from the node definitions):

Nodes that need a plan

A node can need a plan feature (feature on its definition). Pro: HTTP request and every app node and polling trigger (integration), every script node (code), every file node with the Drive (file), the AI agent (ai.agent), knowledge nodes (ai.knowledge), the Chat and MCP triggers. Team: AI browse (ai.browse). Business: Command (system.command). The editor shows a lock on them (picker, canvas, Node details) and you can still add and save them, but a run whose flow, called flows or error flow uses one is refused with "Your plan doesn't include …". The Studio agent only suggests nodes your plan includes. See .

Effect nodes (⚡)

An effect node acts on the outside world: it posts, replies, sends, buys. In a test run effect nodes are simulated: they don't run, they leave through their first output dot with output { "dry": true }, and the log says Dry run: <name> was not executed. So you can test a whole flow safely. A real run asks you to confirm first. Effect nodes in the catalog below carry ⚡. Its kind is act (a like, a delete, a form or email sent) or publish (a post, reply or quote): only publishing counts toward an account's Posts per hour.

Field kinds

Show a field only for a mode

A field can carry show: { <field id>: [values] } (n8n's display options). Node details shows it only when every listed field holds one of its values, and a hidden field isn't required. A credential field that is hidden isn't put in the run either:

{ "id": "credential", "kind": "dataset.credential", "credential": [], "required": true, "show": { "auth": ["credential"] } }

Wait uses it for its modes (show: { "mode": ["until"] }), Merge for its join options, HTTP request for its credential.

Tables, stacks and stages

A node definition can declare what a shows, with no dashboard code:

A row action is a node run with the row's columns as its fields (by name) and the row's account, beside the campaign's run:

{ "action": { "delete": { "node": "x/reply/delete", "confirm": true, "when": ["replied"], "done": "deleted" } } }

Catalog

Trigger

Flow control

Data

Browser

AI

Human

𝕏

Threads

Facebook

Shopee

⚡ = effect node (simulated in test runs).

How a node runs

1. The engine walks the graph from the start node (the trigger, or a called flow's Flow input) with one item, then follows the items along every edge of their dots (a branch finishes before the next starts, top to bottom on the canvas).
2. For each input item (or once for all, run: "once") it resolves the node's fields: expressions are replaced from that item (item), earlier nodes' linked items, vars, option, now (see ); dataset fields are filled from the payload's secrets.
3. It runs the node's compiled code with the (item, items, index, …) and a step AbortSignal (the run's pause/stop plus the node's timeout).
   • Where: a node whose definition has page: true (browser, 𝕏, Threads, Shopee, Human intervention) runs in a Chrome browser (its Browser setting, else the one used last, else default). Every other node (page: false: AI, data, flow, triggers, Approval, Notify; a script node unless its code uses page or tabs) runs in the Chrome browser the run already uses, else in the owner's worker (no Chrome), so a flow without page nodes never starts Chrome ().
4. The node returns { item: [{ dot, json }] }. Items past 1 MB in all are cut (the node's state says how many). Each item goes along every edge of its dot; no edge on that dot ends the path there.
5. In a test run an effect node isn't executed at all: it gives { "dry": true } on its first output dot, and the log says Dry run: <name> was not executed.

FAQ

Why does my node show a ⚠?

A required field is empty, or the node type no longer exists. Fill the field; a run won't start while an active node is missing one.

How do I make a step not stop the whole run when it fails?

Set On error to continue or output (and wire the error dot), or human to decide in the live view.

Can I test only part of a flow?

Yes. Right-click a node: Run this step or Run from here. Earlier outputs come from the last run, or from .

Threads icons

Threads names its nav icons with aria-label (Create, Profile) and a post's icons with an <svg><title> (Like, Unlike, Reply, Repost, More, Verified). The Threads nodes match both: svg[aria-label='Like'], svg:has(> title:text-is('Like')) in Playwright selectors, and the label or title in reads done inside the page. The Post node opens the composer from the nav's New thread (a role=dialog modal), else the floating Create (a role=menu popover), and works in whichever holds the text box. Threads Health checks them all.