Workflow Nodes Reference

This page documents every node available in the Vesbite workflow editor. Nodes are organized into four categories: Triggers (start a workflow), Core Actions (general-purpose logic), Device Actions (interact with devices), and Integration Actions (connect to external services).

Every node produces an output accessible via expressions: {{ output("activityId").property }}.

Here’s an interactive example combining several node types – click Run to see how execution flows through the graph:

Triggers

Triggers determine when and how a workflow starts. Each workflow has exactly one trigger.

Manual Trigger

Starts the workflow on demand via the UI or API.

Category: Core URI: vesbite://triggers/core/manual

Inputs: None.

Outputs:

When to use: Testing workflows during development, on-demand operations that a user initiates manually, or one-off tasks.

Timer Trigger

Starts the workflow on a recurring interval.

Category: Core URI: vesbite://triggers/core/timer

Inputs:

Outputs:

When to use: Periodic polling, recurring checks, or any operation that should repeat at a fixed interval. Minimum resolution is 1 second.

Scheduled (Cron) Trigger

Starts the workflow on a cron schedule. Evaluates at each minute boundary.

Category: Core URI: vesbite://triggers/core/cron

Inputs:

Cron expression format:

 +------------ minute (0-59)
 | +---------- hour (0-23)
 | | +-------- day of month (1-31)
 | | | +------ month (1-12)
 | | | | +---- day of week (0-6, Sunday=0)
 | | | | |
 * * * * *

Supported syntax:

Common examples:

Outputs:

When to use: Scheduled reports, daily data syncs, maintenance tasks, or any operation tied to clock time.

Device Event Trigger

Starts the workflow when a device emits a specific event type.

Category: Devices URI: vesbite://triggers/devices/{definitionId}/{eventName}

Each device definition generates its own Device Event trigger nodes in the workflow editor – one per event type defined in the device schema.

Inputs:

Outputs:

The output fields match the event’s payload schema. For example, a tagread event trigger outputs:

How event data is accessed:

{{ output("triggerActivityId").epc }}
{{ output("triggerActivityId").rssi }}

The trigger unwraps the device event payload so fields are available directly on the output object.

When to use: Reacting to device data in real time – logging tag reads to a database, sending alerts on GPIO changes, triggering business logic when a sensor reports a value.

Core Actions

General-purpose nodes for workflow logic.

Set Variable

Stores a value in the workflow context for use by later nodes.

Category: Core URI: vesbite://actions/core/set-variable

Inputs:

Outputs:

Example use case: Store an intermediate computation result, then reference it in multiple downstream nodes with {{ variables.myVar }}.

Log Message

Writes a message to the workflow execution log for debugging.

Category: Core URI: vesbite://actions/core/log

Inputs:

Outputs:

Example use case: Log the EPC of each tag read during development: Tag read: {{ output("trigger").epc }}.

Delay

Pauses workflow execution for a specified duration. The workflow is suspended and resumed after the delay.

Category: Core URI: vesbite://actions/core/delay

Inputs:

Outputs:

Example use case: Wait 5 seconds after starting a reader before checking for tag reads, or add a cooldown between retries.

HTTP Request

Makes an HTTP request to an external URL and returns the response.

Category: Core URI: vesbite://actions/core/http-request

Inputs:

Outputs:

Example use case: POST tag read data to an external webhook:

• URL: https://api.example.com/tags
• Method: POST
• Body: { "epc": "{{ output("trigger").epc }}" }

Branch

Routes workflow execution down one of two paths based on a boolean condition.

Category: Core URI: vesbite://actions/core/branchHandles: True, False

Inputs:

Outputs:

The Branch node has two output handles. Connect downstream nodes to the True handle for when the condition is truthy, and the False handle for when it is falsy.

Example use case: Check if a tag’s RSSI is above a threshold, then take different actions for strong vs. weak reads.

Device Actions

Nodes that interact with physical devices. These nodes are dynamically generated from device definitions.

Invoke Device Action

Sends a command to a device and returns the result.

Category: Devices URI: vesbite://actions/devices/{definitionId}/{actionName}

Each device definition generates Invoke Device Action nodes for every action in its schema. They appear in the workflow editor grouped under the device type.

Inputs:

Outputs:

Example use case: Start reading on an RFID reader, then process the response to confirm the session began.

Update Device Settings

Pushes new settings values to a device.

Category: Devices URI: vesbite://actions/devices/{definitionId}/update-settings

Inputs:

Outputs:

Example use case: Dynamically adjust reader transmit power based on the time of day or tag population estimates.

Integration Actions

Airtable

Requires an Airtable connection. All Airtable nodes share the Connection and Base ID inputs.

List Bases

Lists all Airtable bases the authenticated user can access.

URI: vesbite://actions/integrations/airtable/list-bases

Inputs:

Outputs: Airtable API response containing bases array with id, name, and permissionLevel for each base.

Get Base Schema

Returns the schema (tables and fields) for a base.

URI: vesbite://actions/integrations/airtable/get-base-schema

Inputs:

Outputs: Airtable API response containing tables array with field definitions.

List Records

Retrieves records from a table with optional filtering and pagination.

URI: vesbite://actions/integrations/airtable/list-records

Inputs:

Outputs: Airtable API response with records array and optional offset for pagination.

Get Record

Retrieves a single record by ID.

URI: vesbite://actions/integrations/airtable/get-record

Inputs:

Outputs: Single record object with id, fields, and createdTime.

Create Record

Creates a single record in a table.

URI: vesbite://actions/integrations/airtable/create-record

Inputs:

Outputs: The created record object with id, fields, and createdTime.

Example use case: Log each RFID tag read to an Airtable table:

{ "EPC": "{{ output('trigger').epc }}", "Antenna": "{{ output('trigger').antenna }}", "Timestamp": "{{ output('trigger').timestamp }}" }

Update Record

Updates a single record.

URI: vesbite://actions/integrations/airtable/update-record

Inputs:

Outputs: The updated record object.

Delete Record

Deletes a single record.

URI: vesbite://actions/integrations/airtable/delete-record

Inputs:

Outputs: Confirmation with id and deleted: true.

Create Records (Batch)

Creates multiple records in a single API call (max 10 per request).

URI: vesbite://actions/integrations/airtable/create-records

Inputs:

Outputs: Array of created records.

Update Records (Batch)

Updates multiple records in a single API call.

URI: vesbite://actions/integrations/airtable/update-records

Inputs:

Outputs: Array of updated records.

Delete Records (Batch)

Deletes multiple records in a single API call.

URI: vesbite://actions/integrations/airtable/delete-records

Inputs:

Outputs: Array of { id, deleted: true } objects.

SendGrid

Send Email

Sends an email through SendGrid.

URI: vesbite://actions/integrations/sendgrid/send-email

Requires a SendGrid connection.

Inputs:

Outputs:

Example use case: Send an alert email when a high-value tag is read, including the tag EPC and timestamp in the email body.

Database Nodes

All database nodes require a connection configured in the Integrations page.

PostgreSQL

Run QueryURI: vesbite://actions/integrations/postgres/run-query

Executes a SELECT query and returns rows.

Execute Non-QueryURI: vesbite://actions/integrations/postgres/execute-non-query

Executes INSERT, UPDATE, or DELETE and returns the affected row count.

Execute ScalarURI: vesbite://actions/integrations/postgres/execute-scalar

Executes a query and returns the first column of the first row.

MySQL

Run QueryURI: vesbite://actions/integrations/mysql/run-query

Same interface as PostgreSQL Run Query.

Execute Non-QueryURI: vesbite://actions/integrations/mysql/execute-non-query

SQL Server

Run QueryURI: vesbite://actions/integrations/sqlserver/run-query

Execute Non-QueryURI: vesbite://actions/integrations/sqlserver/execute-non-query

Oracle

Run QueryURI: vesbite://actions/integrations/oracle/run-query

Execute Non-QueryURI: vesbite://actions/integrations/oracle/execute-non-query

Snowflake

Run QueryURI: vesbite://actions/integrations/snowflake/run-query

Execute Non-QueryURI: vesbite://actions/integrations/snowflake/execute-non-query

MongoDB

Find DocumentsURI: vesbite://actions/integrations/mongodb/find-documents

Queries documents from a collection.

Insert DocumentURI: vesbite://actions/integrations/mongodb/insert-document

Inserts a document into a collection.

Redis

Get ValueURI: vesbite://actions/integrations/redis/get-value

Retrieves a string value by key.

Set ValueURI: vesbite://actions/integrations/redis/set-value

Stores a string value at a key.

Elasticsearch

Search DocumentsURI: vesbite://actions/integrations/elasticsearch/search-documents

Searches an index.

Index DocumentURI: vesbite://actions/integrations/elasticsearch/index-document

Indexes (upserts) a document.

See Also

• Vex Expressions Reference – Expression syntax for node inputs and accessing outputs
• Events Reference – Device event types that feed into Device Event triggers
• Actions Reference – Device action definitions used by Invoke Device Action nodes
• How to Build a Flow