This page explains every node available in the editor. Use it when you need to know what a node does, what you must enter, what data it produces, or whether it works on your target machine.
Each node entry uses the same labels:
| Label |
Meaning |
| Action type |
The internal name stored in the exported package. You normally do not type or change it. |
| Configuration |
The settings you enter in the node properties. |
| Output or Data |
Values that later nodes can read. The exact reference uses the node ID shown in the editor. |
| Flow |
The execution connection that runs next, such as out, success, or failed. |
| Use |
A common reason to choose the node. |
| Runtime |
What happens when the native runner executes the node. |
| Simulation |
What the browser editor can test without performing the real native action. |
| Permission |
An operation that the runner shows for human approval. |
| Capability |
An internal feature category that the runner verifies against the graph. You do not grant capabilities manually. |
| Risk |
The review priority calculated from the operations used by the package. |
A setting described as variable aware accepts either a fixed value or a reference such as {{customer_name}}. A fixed value stays the same for every run. A variable reference is replaced with current runtime data. Variables and Data explains how references work.
Exact package field names are enforced by the linked node schemas. Ordinary editor users do not need to read or edit those schemas.
- Every node may have an optional Custom name for editor readability.
- Triggers begin runs and expose one
out execution handle.
- Ordinary actions continue through
out.
- Fallible actions expose
success and failed. The failed route includes error.message, error.code, error.type, error.retryable, and error.details.
- Runtime output references use the real node ID, for example
{{n-example.status_code}}.
- When one output connects to multiple destinations, the numbered connections execute sequentially in their explicit execution order. Canvas position does not select that order.
- Simulation descriptions are controlled tests. Native runner paths, permissions, devices, processes, and desktop state still require target-machine testing.
- Platform support defaults to all targets, then narrows through desktop-only, explicit target, and configuration-specific rules.
Risk and permission meanings are defined in Approvals, Capabilities, and Risk.
- Action type:
trigger.manual. Capability trigger.manual. Low risk.
- Configuration: none. Only one Manual trigger is allowed per project.
- Output: no trigger-specific data. Continues through
out.
- Use: start a script on demand from Scripts or
baudbound script run SCRIPT.
- Simulation: trigger card starts immediately with optional test payload.
- Action type:
trigger.schedule. Capability trigger.schedule. Low risk.
- Configuration: required Every positive number. Unit
milliseconds, seconds, minutes, hours, or days, default minutes. The resulting interval must be at least one millisecond.
- Output: runner payload includes interval and due-time information. Graph continues through
out.
- Use: recurring work while a background service is active.
- Runtime: unchanged registrations preserve due timing across reload. Missed intervals are counted without dispatching every missed occurrence. Millisecond schedules use operating-system timers and are not hard real-time guarantees.
- Simulation: fires automatically while simulation remains active.
- Action type:
trigger.file_watch. Capability trigger.file_watch. Low risk.
- Configuration: static Path. Optional Include subdirectories for directory targets. Runtime templates are rejected.
- Outputs:
path and normalized event (created, modified, deleted, or renamed).
- Use: react to one file or a directory tree.
- Runtime: target must exist and be accessible when listener registration starts. OS save behavior may emit multiple events.
- Simulation: supplied path/event become outputs. No filesystem watcher is opened.
- Action type:
trigger.webhook. Capability trigger.webhook. Permission webhook_public_bind. High risk.
- Configuration: HTTP Method. Required Hook name. Optional wait switch, positive response timeout, fallback status
100-599, content type, and body.
- Outputs:
method, path, headers, query, raw body, parsed json, and response state.
- Use: receive HTTP at
/events/HOOK_NAME while webhooks are enabled.
- Flow rule: waiting mode requires a reachable Webhook Response node. Timeout uses the configured fallback.
- Simulation: creates a request and response state from supplied payload. It does not open a network port.
- Action type:
trigger.websocket. Capability trigger.websocket. Permission websocket_public_bind. High risk.
- Configuration: required Path beginning with
/, for example /events/messages.
- Outputs: message text, path,
connection_id, headers, query, and remote address.
- Use: begin one run per inbound text message on a matched connection.
- Runtime: requires enabled WebSocket listener and connection capacity. Use WebSocket Write with this run's connection ID.
- Simulation: supplies a synthetic connection when one is not entered.
- Action type:
trigger.hotkey. Capability trigger.hotkey. Medium risk. Windows Desktop only.
- Configuration: required captured Key expression. A single key such as
G, F1, or MediaPlayPause is valid. Any distinct supported keys can form a chord, including K+L, F1+T, and Ctrl+Shift+B. See Supported Windows node keys for the exact names.
- Output: canonical
key expression and timestamp.
- Use: start a script when the complete physical key chord is held while the Windows desktop background runner is active.
- Matching: the held keys must match the configured chord exactly. The run starts when the final required key is pressed, regardless of the order in which the keys were pressed. Holding the chord does not repeatedly start runs.
- Platform: Windows Desktop only. Firmware-only
Fn keys and Windows secure-attention input such as Ctrl+Alt+Delete are not available.
- Simulation: uses the supplied or configured expression. It does not register a global OS hook.
- Action type:
trigger.serial_input. Capability trigger.serial_input. Permission serial_input. High risk.
- Configuration: required logical Device id. Lowercase letters, numbers,
_, and - only.
- Outputs:
device_id, received data, byte count, and runner timestamp.
- Use: start when a runner-mapped serial device emits data.
- Runner framing: the runner mapping decides whether a complete message ends after an idle gap, at a line ending, or at each raw operating system chunk. Multiple Serial Input nodes using the same logical ID share one native reader.
- Graph rule: the same device ID cannot be used by two Serial Input triggers in one project.
- Simulation: supplied text produces output and UTF-8 byte length without opening a port.
- Action type:
trigger.startup. Capability trigger.startup. Permission startup_trigger. High risk.
- Configuration: none.
- Output: startup reason and service context where available.
- Use: run once when an eligible script is loaded by a newly started service session.
- Simulation: reports a synthetic
runner_startup reason.
- Action type:
trigger.process_started. Capability trigger.process_started. Medium risk.
- Configuration: Match by process name, executable path, or window title. Required Target.
- Outputs: process name, process ID, executable path, and window title where available.
- Platform: window-title matching requires Windows Desktop. Other modes support compatible Windows/Linux targets.
- Runtime: polling dispatches when a process first appears, not continuously while the same process remains present.
- Simulation: uses supplied process facts or stable sample values.
- Action type:
control.if. Capability runtime.if. Low risk.
- Configuration: one or more condition rows with a value, operator, optional inversion, and AND/OR combinator. Operators that compare two values also show a target.
- Flow: named
true and false outputs.
- Text operators: equality, ordering, contains, does not contain, prefix, suffix, regular expression, and case insensitive equality or contains checks.
- Collection operators: has key checks an object key. contains item checks a list item. Length operators compare string characters, list items, or object keys with Target.
- Type operators: Is numeric, Is text, Is boolean, Is list, and Is object check the resolved value type. Is numeric also accepts text that contains only a valid finite number.
- Presence operators: Is defined passes when a variable reference exists. Its value may still be null. Is missing passes when that variable reference does not exist.
- Checks without a target: empty, null, boolean, type, and presence checks inspect Value directly, so the editor does not show a Target field for them. Boolean checks match only real boolean values. Text such as
"true" and "false" does not match.
- Simulation/runtime: values are resolved with their types before comparison. A numeric variable or calculated result matches an equivalent numeric literal, so calculated
1.0 equals the literal 1. Two text values still require exactly the same text. Inversion applies to one row before combinators.
- Example:
{{status_code}} >= 400 routes errors to true.
- Action type:
control.color_match. It uses capability runtime.color_match, has low risk, and does not request a permission.
- Configuration: Actual color, Expected color, Comparison mode, and a variable-aware Tolerance from
0 through 100 percent.
- Accepted colors: canonical hex such as
#2F80ED, RGB text such as rgb(47, 128, 237), or a typed RGB object with exactly r, g, and b integer channels from 0 through 255.
- Flow:
match runs when the measured difference is less than or equal to the tolerance. no match runs for any valid pair outside the tolerance. Exactly one branch runs.
- Per channel mode: compares the largest red, green, or blue channel difference against the percentage tolerance. This is useful when no individual channel may drift too far.
- Total RGB distance mode: compares the normalized three-dimensional distance between the colors. This allows channel differences to contribute to one overall similarity value.
- Outputs:
matches, difference_percent, red_difference, green_difference, and blue_difference remain available to later nodes through the Color Match node ID.
- Validation:
0 percent requires exact equality. 100 percent accepts every pair of valid RGB colors. Invalid or dynamically resolved malformed colors stop the node with an execution error instead of following no match.
- Get Pixel Color example: set Actual color to
{{n-pixel.rgb}}, set Expected color to #2F80ED, choose a comparison mode, and enter the acceptable tolerance. The RGB object is passed directly without converting it to text.
- Other examples: compare two literals such as
#101820 and rgb(16, 24, 32), or compare RGB object variables from any source. Color Match is available on every target runtime because it only compares data and does not read the screen.
- Action type:
control.switch. Capability runtime.switch. Low risk.
- Configuration: variable-aware Value and ordered case rows with stable IDs, labels, and expected values.
- Flow: one named output per case and an always available
default output.
- Runtime: the first equal case wins. When no case matches, the runner follows
default. Numeric variables and calculated results match equivalent numeric literals even when their displayed formatting differs. Two text values still require exactly the same text.
- Example: route
{{event_type}} to created, updated, or default.
- Action type:
control.repeat. Capability runtime.repeat. Low risk.
- Configuration: a variable-aware whole-number Repeat count from
1 through 18446744073709551615.
- Flow:
repeat executes the body once for every iteration. done continues after every iteration finishes or after Break Loop ends the Repeat early.
- Graph rule: let the body end naturally. Do not connect the body back to Repeat because the runner starts each new iteration automatically.
- Simulation: repeats the body with the same count and flow behavior used by the runner.
- Action type:
control.break_loop. Capability runtime.break_loop. Low risk.
- Placement: connect it inside the body of Repeat, While, or For Each.
- Flow: ends the nearest active loop immediately and continues from that loop's
done output.
- Nested loops: only the innermost active loop ends. An outer loop continues normally.
- Ports: it has an input but no output because execution resumes from the loop's
done output.
- Failure: verification rejects a Break Loop that is not inside a loop body. The runner also stops with a clear error if an invalid package reaches this state.
- Action type:
control.continue_loop. Capability runtime.continue_loop. Low risk.
- Placement: connect it inside the body of Repeat, While, or For Each.
- Flow: skips every remaining step in the current iteration and starts the nearest loop's next iteration.
- Nested loops: only the innermost active loop advances.
- Ports: it has an input but no output because execution returns directly to the loop.
- Completion: when no next iteration exists, the loop continues from its
done output.
- Failure: verification rejects a Continue Loop that is not inside a loop body. The runner also stops with a clear error if an invalid package reaches this state.
- Action type:
control.while. Capability runtime.while. Low risk.
- Configuration: the same condition rows and inversion behavior as If/Else.
- Flow:
loop executes while conditions pass. done follows the first false result.
- Graph rule: no explicit edge returns to While.
- Safety: ensure body state can make the condition false. Runtime limits and cancellation remain important.
- Action type:
control.for_each. Capability runtime.for_each. Low risk.
- Configuration: variable-aware Items resolving to a list.
- Flow:
loop runs once per item. done follows completion.
- Data:
{{node-id.item}} holds the current item and {{node-id.index}} holds its zero-based index. Replace node-id with the ID shown in the node's Runtime Data section.
- Failure: non-list input fails control-flow validation/execution.
- Example: for a node with ID
n-example, read the active item with {{n-example.item}} and its position with {{n-example.index}}.
¶ Data and Output
- Action type:
runtime.set_variable. Capabilities runtime.variables and, for stored scopes, runtime.persistent_storage. Fallible.
- Configuration: operation
set, increment, append_list, set_object_field, or clear. Name. Scope runtime, persistent, or global. Value type. Operation-specific value and field path.
- Access: runtime scope is low, persistent is medium, global is high.
- Data: writes
{{name}} and refreshes $length, $count, $type, and $is_empty.
- Validation: names use letters, numbers, and underscores, cannot start with a number, and cannot use reserved prefixes.
- Failure: invalid values, incompatible existing values, invalid object paths, and storage write errors continue through
failed with structured error details. A failed operation does not modify the variable.
- Simulation: updates current simulation state. Runner persistence must be tested separately.
- Action type:
action.calculate. Capability action.calculate. Permission calculate. Low risk. Fallible.
- Configuration: variable-aware numeric Expression.
- Output:
result number on success. Structured error on failure.
- Use: arithmetic supported by the runtime expression evaluator, not arbitrary code.
- Simulation: evaluates with current values using the same supported expression rules.
- Action type:
action.value.convert. Capability action.value. Permission value_conversion. Low risk. Fallible.
- Configuration: a variable-aware Value and a target type of text, number, integer, boolean, list, or object.
- Integer rules: the value must already be a whole number within the safe integer range. Convert Value does not round decimal values.
- Boolean rules: accepts a boolean value or the text
true or false without regard to letter case.
- List and object rules: accepts an existing value of the selected type or JSON text whose top-level value has the selected type.
- Output:
value, source_type, and target_type on success. Structured error details are available from failed.
- Action type:
action.text.format. Capability action.text. Permission text_transform. Low risk. Fallible.
- Configuration: one initial input followed by an ordered list of operations. Drag operations to change their order.
- Operations: template, trim, uppercase, lowercase, sentence case, capitalize words, literal/regex replace, split, join, substring, padding, URL/Base64 encode/decode, and JSON escape/unescape.
- Order: each operation receives the result from the operation above it. Split changes text into a list. Join changes a list back into text.
- Output: the final value is available as
text or items according to its type.
- Failure: invalid regex, encoding, indexes, or an incompatible value type continues through
failed.
- Action type:
action.url.parse. Capability action.text. Permission parse_url. Low risk. Fallible.
- Configuration: a variable-aware absolute URL. Standard protocols such as
https and custom protocols such as ptr are supported.
- Outputs:
protocol, host, port, path, raw query, decoded query_parameters, and fragment.
- Query parameters: an ordered list of objects with
name and value fields. Repeated names remain separate entries and keep their original order.
- Failure: missing, relative, and malformed URLs continue through
failed with structured error details.
- Example:
ptr://command/move?param=value1 produces protocol ptr, host command, path /move, and query parameters [ { "name": "param", "value": "value1" } ].
- Action type:
action.log. Capability action.log. Permission log. Low risk.
- Configuration: level
info, warn, error, or debug. Variable-aware Message.
- Output: no action-specific data. Continues through
out.
- Runtime: stores the resolved message with node and run identity.
- Security: do not intentionally log secrets or untrusted payloads without review.
- Action type:
action.delay. Capability action.delay. Permission delay. Low risk. Fallible.
- Configuration: variable-aware positive Amount and unit milliseconds, seconds, minutes, hours, or days. The resolved duration must be at least one millisecond.
- Flow:
success continues after the cancellable wait. An invalid resolved duration continues through failed with structured error details. Cancelling a run stops execution instead of following failed.
- Simulation: validates the resolved duration and records the simulated delay without blocking the UI thread.
- Action type:
action.beep. Capability action.sound. Permission beep. Low risk. Desktop only. Fallible.
- Configuration: required variable-aware positive frequency Hz and duration ms.
- Flow/data: success or failed with structured error.
- Runtime: plays a generated tone through the default desktop audio output.
- Simulation: Web Audio sine tone clamped to safe editor bounds. Browsers may block audio before interaction.
- Action type:
action.notification. Capability action.notification. Permission show_notification. Medium risk. Desktop only. Fallible.
- Configuration: variable-aware Title and Message.
- Output: success/failure state.
- Simulation: editor toast rather than native notification-center behavior.
- Action type:
action.message_box. Capability action.message_box. Permission show_message_box. Medium risk. Windows Desktop only. Fallible.
- Configuration: type info/warning/error. Title. Message. Buttons OK, OK/Cancel, Yes/No, or Yes/No/Cancel.
- Output: selected button plus success/failure data.
- Simulation: modal inside the editor. Stop aborts a waiting selection.
- Action type:
action.sound.play. Capability action.sound. Permission play_sound. Medium risk. Desktop only. Fallible.
- Configuration: source package asset or file path and corresponding selected path.
- Output: played source/path information and failure data.
- Simulation: plays package audio in the browser. A runner filesystem path cannot be tested there.
¶ Network and Serial
- Action type:
action.http. Capability action.http. Permission http_request. Medium risk. Fallible.
- Configuration: method, body format, variable-aware URL, headers, body, timeout
1-300 seconds, and user agent.
- JSON bodies: JSON mode parses the body before variables are inserted. Put variable references inside JSON string quotes. A reference that fills the complete string keeps its original type. Strings are escaped safely, including quotes, backslashes, carriage returns, and newlines.
- Text bodies: Text mode inserts variables directly and sends the resulting text without JSON processing.
- Existing projects: when body format is not present, the runner treats the body as JSON if its
Content-Type is application/json or an application/*+json media type.
- Outputs: status code/text, headers, body, optional parsed
json, duration, or structured network error.
- Runtime: native HTTP client behavior may differ from browser redirects, CORS, forbidden headers, cookies, and TLS stores.
- Simulation: sends a real browser
fetch. Use a safe test endpoint.
- Action type:
action.webhook_response. Capability action.webhook_response. Permission webhook_response. Low risk. Fallible.
- Configuration: variable-aware status
100-599, content type, headers, and body.
- Outputs:
sent, status, content type, headers, body, owning trigger_id, or error.
- Graph rule: must be reachable from a Webhook trigger with waiting enabled.
- Runtime: exactly one response owns one pending request.
- Action type:
action.websocket.write. Capability action.websocket. Permission websocket_write. Medium risk. Fallible.
- Configuration: variable-aware Connection id and Message.
- Outputs: send result/byte information or connection error.
- Use: reply to the connection ID emitted by the WebSocket trigger for the current run.
- Failure: unknown, stale, or disconnected IDs are rejected.
- Action type:
action.serial.write. Capability action.serial. Permission serial_write. Medium risk. Fallible.
- Configuration: logical device ID selected from Serial Input triggers, variable-aware data, and line ending none/LF/CRLF.
- Output: write result or structured serial error.
- Runner connection: Serial Write uses the same logical-device connection as Serial Input. It does not open a competing port handle when a reader is active.
- Graph rule: requires a Serial Input trigger using the same logical ID.
- Simulation: reports intended bytes and line ending without opening hardware.
- Action type:
action.file.read. Capability action.file. Permission file_read. Medium risk. Fallible.
- Configuration: variable-aware path and UTF-8 encoding.
- Outputs: content, byte count, resolved path, or error.
- Access: absolute, sensitive, or runtime-selected paths require the dangerous
read_sensitive_file permission instead of file_read.
- Simulation: sample output only. Runner account permissions and file existence remain untested.
- Action type:
action.file.write. Capability action.file. Permission file_write_limited. High risk. Fallible.
- Configuration: variable-aware path/content and mode overwrite or append.
- Outputs: resolved path, bytes written, mode, or error.
- Access: absolute, sensitive, or runtime-selected paths require the dangerous
write_any_file permission instead of file_write_limited.
- Review: paths can be influenced by variables. Confirm they cannot escape intended storage.
- Action type:
action.file.download. Capabilities action.file and network behavior. Permission download_file. Medium risk. Fallible.
- Configuration: variable-aware URL and destination path. Overwrite switch.
- Outputs: destination, transferred size/status information, or error.
- Access: an absolute, sensitive, or runtime-selected destination also requires
write_any_file.
- Review: validate both remote source and local overwrite consequences.
- Action type:
action.file.delete. Capability action.file. Permission delete_file. Dangerous. Fallible.
- Configuration: variable-aware path.
- Output: deleted path or error.
- Warning: deletion is not a recycle-bin operation. Restrict input and test on disposable data.
- Action type:
action.file.copy. Capability action.file. Permission file_copy. Medium risk. Fallible.
- Configuration: variable-aware source and destination. Overwrite switch.
- Outputs: resolved paths, copy result, or error.
- Access: a broad source requires
read_sensitive_file. A broad destination requires write_any_file.
- Action type:
action.file.move. Capability action.file. Permission file_move. Medium risk. Fallible.
- Configuration: variable-aware source and destination. Overwrite switch.
- Outputs: resolved paths, move result, or error.
- Access: a broad source requires
read_sensitive_file. A broad destination requires write_any_file.
- Review: a successful move removes the original path.
¶ Processes and Windows
- Action type:
action.process.run. Capability action.process. Permission run_process. Dangerous risk. Fallible.
- Configuration: variable-aware executable, arguments, optional working directory, and optional timeout from
1 to 86400 seconds, default 300.
- Outputs: process ID, exit code, success flag, captured standard output, captured standard error, or action error.
- Runtime: uses native process APIs, not shell parsing. Arguments must match the target executable's contract.
- Action type:
action.process.status. Capability action.process. Permission process_query. Medium risk. Fallible.
- Configuration: match by process name, executable path, or window title. Variable-aware target.
- Outputs: running flag, matching process information, or error.
- Platform: window-title mode requires Windows Desktop.
- Action type:
action.process.kill. Capability action.process. Permission process_kill. High risk. Fallible.
- Configuration: match by process name, executable path, window title, or PID. Variable-aware target.
- Outputs: matched/terminated process information or error.
- Platform: window-title mode requires Windows Desktop.
- Action type:
action.application.open. Capability action.window. Permission open_application. Medium risk. Desktop only. Fallible.
- Configuration: variable-aware application name/ID/shortcut/desktop entry and arguments.
- Outputs: resolved application ID and process ID when exposed.
- Simulation: returns sample IDs without opening an application.
- Action type:
action.window.active. Capability action.window. Permission window_query. Medium risk. Windows Desktop only. Fallible.
- Configuration: none.
- Outputs: window title, process ID/name, executable path, and native handle where available.
- Simulation: sample window data. No native lookup.
- Action type:
action.window.focus. Capability action.window. Permission window_focus. High risk. Windows Desktop only. Fallible.
- Configuration: match by process name, executable path, or window title. Variable-aware target.
- Outputs: focused window/process details or error.
- Review: focus changes can redirect subsequent keyboard or mouse actions.
- Action type:
action.pixel.get. Capability action.pixel. Permission screen_pixel_read. Medium risk. Windows Desktop only. Fallible.
- Configuration: variable-aware signed integer screen X and Y coordinates from
-2147483648 through 2147483647.
- Outputs: coordinates, RGB channels, hex color, and error on failure.
- Simulation: deterministic sample color derived for testing, not a real screenshot read.
- Runtime: coordinates use the Windows virtual desktop. Negative values address monitors to the left of or above the primary display. Points in gaps between monitors are rejected.
- Tools: use the desktop runner coordinate picker to select a point and copy its X coordinate, Y coordinate, pair, or sampled color.
- Action type:
action.clipboard.set. Capability action.clipboard. Permission write_clipboard. Medium risk. Desktop only. Fallible.
- Configuration: variable-aware value to write.
- Output: written text, its UTF-8 byte length, or an error.
- Review: replaces the user's current clipboard and may expose data to other applications.
- Action type:
action.clipboard.get. Capability action.clipboard. Permission read_clipboard. Medium risk. Desktop only. Fallible.
- Configuration: none.
- Output: clipboard text or an error when text is unavailable.
- Review: clipboard text can contain passwords or other sensitive data. Avoid sending it to logs or external services unless that is intentional.
- Platform: requires a signed-in Windows or Linux desktop session with a working native clipboard provider.
- Action type:
action.keyboard. Capability action.keyboard. Permission keyboard_control. High risk. Windows Desktop only. Fallible.
- Configuration: choose an input action and one or more distinct supported keys. The editor can capture the keys or add them with the key reference buttons. Separate chord members with
+, for example G, F1, K+L, or Ctrl+Shift+S.
- Supported keys: uses the same Supported Windows node keys as the Hotkey trigger. Unsupported names are rejected instead of being guessed.
- Platform: Windows Desktop only.
- Output: the normalized key expression, the performed input action, or an error.
- Review: ensure the intended application has focus. Use Type Text for words and arbitrary text.
The input action controls what happens to every key in the configured chord.
| Input action |
Behavior |
| Press and release |
Performs a normal key press. Modifier keys are pressed first, the final key is pressed and released, then the modifiers are released. |
| Press down |
Holds every configured key. A later Keyboard node can release the same keys. |
| Release |
Releases only keys held by the current run. Using Release without a matching Press down is safe and does nothing. |
Held keys belong to the run that pressed them. The runner releases them automatically when that run completes, fails, or is stopped. When concurrent runs hold the same key, the physical key is released only after every owning run has released it or ended.
Hotkey and Keyboard nodes use one shared Windows key contract. The editor, exported package checks, global hotkey service, and native Keyboard action all validate the same names. The editor captures held keys and also provides a button for every canonical key name.
| Group |
Supported canonical names |
| Modifiers |
Ctrl, Alt, Shift, Windows |
| Letters and digits |
A through Z, 0 through 9 |
| Function |
F1 through F24 |
| Navigation and editing |
Escape, Enter, Space, Tab, Backspace, Delete, Insert, Home, End, PageUp, PageDown, ArrowUp, ArrowDown, ArrowLeft, ArrowRight |
| System and lock |
CapsLock, NumLock, ScrollLock, PrintScreen, Pause, ContextMenu |
| Punctuation |
Semicolon, Equal, Comma, Minus, Period, Slash, Backquote, BracketLeft, Backslash, BracketRight, Quote, IntlBackslash |
| Numpad |
Numpad0 through Numpad9, NumpadMultiply, NumpadAdd, NumpadSeparator, NumpadSubtract, NumpadDecimal, NumpadDivide |
| Browser |
BrowserBack, BrowserForward, BrowserRefresh, BrowserStop, BrowserSearch, BrowserFavorites, BrowserHome |
| Media and volume |
VolumeMute, VolumeDown, VolumeUp, MediaNext, MediaPrevious, MediaStop, MediaPlayPause |
| Application launch |
LaunchMail, LaunchMedia, LaunchApp1, LaunchApp2 |
Firmware-managed keys such as Fn and Windows secure-attention input such as Ctrl+Alt+Delete cannot be captured or generated. Browser, media, and Windows-key combinations may also be reserved by the browser, Windows, or another application. Build those combinations with the key-reference buttons when the browser cannot capture them. For example, pressing Ctrl+W normally asks the browser to close the tab, so use the Ctrl and W buttons instead.
- Action type:
action.keyboard.type_text. Capability action.keyboard. Permission keyboard_control. High risk. Windows Desktop only. Fallible.
- Configuration: variable-aware text.
- Platform: Windows Desktop only.
- Output: typed length/status or error.
- Security: never type secrets into an unverified foreground target.
- Action type:
action.mouse. Capability action.mouse. Permission mouse_control. High risk. Windows Desktop only. Fallible.
- Configuration: choose left, right, middle, back, or forward and then choose an input action. Single and double click are available for Press and release.
- Output: the mouse button, the performed input action, click type when applicable, or an error.
- Platform: Windows Desktop only.
- Runtime: acts at the current pointer position.
| Input action |
Behavior |
| Press and release |
Performs a single or double click. |
| Press down |
Holds the selected mouse button. |
| Release |
Releases the selected button only when the current run holds it. |
Held mouse buttons use the same run ownership and automatic cleanup as held keyboard keys. The runner releases them when the run completes, fails, or is stopped.
- Action type:
action.mouse.move. Capability action.mouse. Permission mouse_control. High risk. Windows Desktop only. Fallible.
- Configuration: variable-aware signed integer X/Y and relative switch.
- Output: final coordinates/movement details or error.
- Platform: Windows Desktop only.
- Runtime: absolute coordinates use the Windows virtual desktop and must belong to a connected monitor. Relative values remain signed offsets from the current pointer position.
- Review: use the runner Tools tab to inspect monitor ranges and display scaling or select an exact point with the coordinate picker.
¶ Scripts and System
- Action type:
action.script.run. Capability action.sub_script. Permission sub_script_run. High risk. Fallible.
- Configuration: installed child script name or ID.
- Outputs: child run ID/status/report summary or error.
- Runtime: child must be independently installed, valid, current, approved, and manually runnable. Parent approval does not approve the child.
¶ Shell Command
- Action type:
action.shell. Capability supplied through process execution. Permission run_shell_command. Dangerous. Fallible.
- Configuration: variable-aware command string interpreted by the target shell and optional timeout from
1 to 86400 seconds, default 300.
- Outputs: exit code, stdout, stderr, or error.
- Platform: syntax is platform-specific even under a Generic target.
- Warning: prefer a native node or Run Process. Shell interpolation can turn data into arbitrary commands and has independent runner policy gates.