Design automation flows with less friction.

Start the workflow manually from the toolbar with the Execute button.

• No fields — useful for testing and one-off runs.

Manual trigger with an inline text box. Type data and send it downstream.

• defaultText — optional pre-filled text for the custom trigger body.

Fires the workflow whenever someone sends a WhatsApp message to your registered Business phone number. The user's message body is exposed as {{input.data.text}}, matching the shape of the Text Input trigger so downstream LLM / transform / output nodes work without changes.

• phoneNumberId — Business Phone Number ID from Meta Business Suite (required)
• fromFilter — optional E.164 sender filter, e.g. +15551234567
• pollInterval — seconds between inbox polls (default 15)

{{input.data.text}}        // user's message body
{{input.from}}             // sender phone (E.164)
{{input.profileName}}      // sender display name
{{input.messageId}}        // Meta wamid.*
{{input.phoneNumberId}}    // your business number id

1. In Meta Business Suite → WhatsApp → Configuration, set the Callback URL to https://<your-host>/api/WorkflowProxy/whatsapp/webhook and the Verify Token to the value of WhatsApp:VerifyToken in appsettings.json.
2. Subscribe to the messages webhook field.
3. Activate this workflow — the front-end starts polling the buffered inbox every pollInterval seconds and fires once per new message.

Fires the workflow when a user posts in any channel your Slack bot is in. Bot messages are auto-filtered. The message text is exposed as {{input.data.text}}, matching the Text Input trigger shape.

• teamId — Slack workspace ID, e.g. T01ABCDEF (required)
• channelFilter — optional channel ID, e.g. C01ABCDEF
• userFilter — optional user ID, e.g. U01ABCDEF
• pollInterval — seconds between inbox polls (default 10)

{{input.data.text}}      // message text
{{input.from}}           // Slack user id
{{input.channelId}}      // channel id
{{input.teamId}}         // workspace id
{{input.messageTs}}      // Slack ts (use as message id)

1. Create a Slack app at api.slack.com/apps, enable Event Subscriptions, and set the Request URL to https://<your-host>/api/WorkflowProxy/slack/webhook — the server auto-replies to the url_verification challenge.
2. Subscribe to message.channels (and/or message.im, message.groups) under Bot Events, then reinstall the app.
3. Copy the Signing Secret into Slack:SigningSecret in appsettings.json — without it the server rejects unsigned requests when the key is set, but accepts everything when blank (test mode only).

Fires the workflow when a user runs a slash command on your Discord application. The concatenated command arguments are exposed as {{input.data.text}}. Note: Discord's Interactions endpoint only delivers slash commands, not arbitrary channel chatter.

• applicationId — Discord Application ID (required)
• guildFilter — optional Guild (server) ID
• channelFilter — optional Channel ID
• commandFilter — optional slash-command name (without leading /)
• pollInterval — seconds between inbox polls (default 10)

{{input.data.text}}     // joined slash-command arguments
{{input.from}}          // username
{{input.userId}}        // Discord user id
{{input.guildId}}       // server id
{{input.channelId}}     // channel id
{{input.commandName}}   // e.g. "ask"
{{input.interactionId}} // Discord interaction id

1. Create an app at discord.com/developers/applications. Under General Information, set the Interactions Endpoint URL to https://<your-host>/api/WorkflowProxy/discord/webhook.
2. Copy the Public Key into Discord:PublicKey in appsettings.json — Discord won't accept the URL until Ed25519 verification passes.
3. Register your slash commands via POST /applications/{app-id}/commands (one-shot script).

Fires the workflow when a user messages your Telegram bot (private, group, or channel). The message text is exposed as {{input.data.text}}.

• botId — bot username (no @) or numeric ID (required)
• chatFilter — optional chat ID, e.g. -1001234567890
• commandFilter — optional command prefix, e.g. /start
• pollInterval — seconds between inbox polls (default 10)

{{input.data.text}}    // message text or caption
{{input.from}}         // sender display name
{{input.chatId}}       // chat id
{{input.messageId}}    // Telegram message_id
{{input.profileName}}  // sender first/last name
{{input.commandName}}  // e.g. "start" if message starts with /

1. Get a bot token from @BotFather and put it in Telegram:BotToken in appsettings.json (also Telegram:BotId or Telegram:BotUsername so the inbox key is set).
2. Generate any random secret and set Telegram:WebhookSecret in appsettings.json.
3. Register the webhook: https://api.telegram.org/bot<TOKEN>/setWebhook?url=https://<your-host>/api/WorkflowProxy/telegram/webhook&secret_token=<your-secret>.

Fires the workflow when a Teams channel member @mentions your Outgoing Webhook bot. The message text (with mention markup stripped) is exposed as {{input.data.text}}.

• webhookId — identifier you choose, appended to the callback URL as ?id=<webhookId> (required)
• fromFilter — optional sender display name
• pollInterval — seconds between inbox polls (default 10)

{{input.data.text}}      // message text (cleaned)
{{input.from}}           // sender display name
{{input.userId}}         // AAD object id
{{input.channelId}}      // Teams channel id
{{input.teamId}}         // Teams team id
{{input.conversationId}} // conversation thread id
{{input.messageId}}      // Teams activity id

1. In the target Teams channel: ⋯ → Manage channel → Connectors → Outgoing Webhook → Configure.
2. Set the Callback URL to https://<your-host>/api/WorkflowProxy/teams/webhook?id=<webhookId> (use the same webhookId on the node).
3. Copy the displayed Security token into Teams:WebhookSecret:<webhookId> in appsettings.json (or Teams:WebhookSecret for a single global webhook).
4. @mention the bot in the channel to test — the workflow fires once per mention.

Run the workflow when an external HTTP request hits the generated webhook URL.

• path — webhook route, e.g. /my-webhook
• responseCode — HTTP status returned to the caller (default 200)

Run the workflow on a recurring timer using a simple interval or cron expression.

• interval — minutes between runs in Simple mode (default 60)
• cron — cron expression, e.g. 0 */2 * * *
• timezone — default UTC

Fire when a user chat prompt matches a keyword, exact phrase, regex, or AI intent.

• pattern — keywords, exact phrase, or regex
• confidence — minimum score for Intent (AI), default 0.7
• caseSensitive — toggle case-aware matching

Start from an event emitted by a connected service such as Gmail, Slack, Discord, or GitHub.

• channelId — service channel, room, or stream identifier
• filter — optional filter expression

React to internal Verse AI events from chat, Verse Link, Circuit, Desktop, or Versona Hub.

• eventName — built-in event name (default chat.message)
• customEvent — shown when eventName is custom

Poll an inbox and start the workflow when matching mail arrives.

• folder / label — default INBOX
• filterFrom · filterSubject · onlyUnread
• withAttachments · pollInterval · markAsRead

Start when files are created, modified, or deleted in a watched location.

• watchPath — path or pattern, e.g. /uploads/*.pdf
• watchEvents — All / Created / Modified / Deleted
• recursive · fileFilter · pollInterval (default 30 seconds)

Call any REST API with full control over method, headers, body, and timeout.

• url — endpoint (supports {{input.data.*}})
• headers — JSON object
• body · timeout (default 30000 ms)

Send a prompt to Verse AI or any of your Versonas.

• model — Verse AI or a stored Versona (dynamic list)
• systemPrompt · userPrompt
• temperature (default 0.7) · maxTokens (default 2000)

Send transactional or notification emails via Gmail SMTP.

• to · subject · body (supports {{variables}})
• isHtml — render body as HTML
• attachInput — attach file from a File Generator upstream

Push a notification to a user across multiple delivery channels.

• title · message

Execute SQL against SQL Server or PostgreSQL with parameterized queries (SQL-injection safe).

• connection — Stored Credentials or Default (App DB)
• query — use @param placeholders
• parameters — JSON map of @param → value
• maxRows — row cap

Return an HTTP response to whoever called a Webhook trigger upstream — required for synchronous webhooks.

• statusCode (default 200)
• headers — JSON of extra headers
• body — supports {{input.data}} interpolation

Reshape an object using an expression or a small JavaScript snippet.

• expression — e.g. return { summary: input.data.response };
• keepOriginal — merge with the original fields (default true)

Assign, rename, or drop fields without writing code — the codeless alternative to Transform.

• assignments — JSON map; values may use {{input.data.*}}
• drop — comma-separated field names to remove

Parse, stringify, query (JSONPath), merge, pick, or omit fields.

• source (default input.data)
• expression — JSONPath or comma list of fields
• mergeWith · indent (default 2)

Parse CSV text into rows, or convert rows back to CSV.

• delimiter (default ,) · quote (default ")
• hasHeaders — first row is column names

Convert XML ↔ JSON — useful for SOAP and RSS integrations.

• source (default input.data)
• rootElement — only used for Stringify (default root)

Read and write .xlsx workbooks (powered by SheetJS). Files travel as base64.

• source — fileBase64 for Parse, rows for Build
• sheetName — only for Build (default Sheet1)

Match, extract, replace, or split text with a regular expression.

• pattern — JS regex source
• flags (default gi)
• replacement — only for Replace

Render a Handlebars-style template with full input context. Supports {{var}}, {{#if}}, and {{#each}}.

• template — multi-line text body
• outputField — where to write the rendered string (default rendered)

Validate input against a JSON Schema and branch into valid or invalid.

• source — what to validate (default input.data)
• schema — JSON Schema document

Collect items emitted from a loop, group them, or reduce to sum / avg / count. Pairs with Loop / Iterate or Split In Batches.

• field · batchSize (when applicable)

Split an array into chunks of N items and iterate downstream — ideal for rate-limited APIs.

• sourceField (default input.data)
• batchSize (default 10) · delayMs · maxBatches (default 1000)

Get the current time, parse, format, do arithmetic, diff, or convert timezones.

• customFormat — e.g. YYYY-MM-DD HH:mm:ss
• timezone — IANA name (e.g. America/New_York)

Safely evaluate arithmetic expressions or run statistics over an array.

• expression — e.g. (input.data.price * input.data.qty) * 1.08
• arrayField — for stats operations

Generate one or more unique identifiers in several common formats.

• count (default 1)
• outputField (default id)

Hash data, generate HMACs, or encode/decode — ideal for signing outbound API requests (Stripe, GitHub, AWS…).

• inputField — value to hash/encode
• secret — required for HMAC-SHA256 (stored as a password field)
• outputEncoding — hex or base64

Read and write variables that persist across all nodes within a single workflow run.

• varName · varValue
• incrementBy (default 1) · outputField (default varValue)

Download, upload, read, write, and convert files across multiple storage backends.

• filePath · contentField · encoding · mimeType

Pause workflow execution before continuing — useful for polling or rate limiting.

• duration (default 5)

Run another saved workflow as a sub-routine and (optionally) wait for its result — the building block of modular workflows.

• workflowId — id like wf-abc123 or display name
• inputOverride — JSON to pass instead of the current input
• waitForResult — synchronous (default true) vs fire-and-forget

Pause the workflow until a human approves or rejects in the Approvals UI — the human-in-the-loop gate.

• title · message (supports {{input.data.*}})
• approveLabel · rejectLabel
• timeoutMinutes — 0 means wait forever

Catch errors from upstream nodes and route them to a recovery branch instead of failing the run.

• suppressError — keep the workflow running (default true)
• matchPattern — only catch errors matching a regex (e.g. ^(rate limit|timeout))

Issue an HTTP request and automatically retry on failure with configurable backoff.

• url · headers · body
• maxAttempts (default 3) · baseDelayMs (default 500)
• retryOnStatus — comma list (default 408,429,500,502,503,504)

Branch the workflow based on a single comparison.

• field — value to test (e.g. {{input.data.status}})
• operator · value · dataType (String / Number / Boolean)

Multi-way branch — route input to one of three case ports or the default fallback.

• field — switch expression (e.g. {{input.data.type}})
• case1 · case2 · case3 — values to match

Combine two upstream branches (in1 + in2) into a single output.

• mode — merge strategy
• mergeKey — required when mode = Merge By Key

Walk every item in an array, emitting each one downstream until the array is exhausted.

• sourceField — array path (e.g. {{input.data.items}})
• batchSize — items per emit (default 1)
• maxIterations — safety cap (default 100)

Repeat a branch while a condition holds true — condition-driven (not item-driven).

• conditionField · operator · conditionValue
• maxIterations (default 100) · delayMs between iterations

Reshape an array — filter, sort, deduplicate, limit, reverse, or flatten.

• sourceField — array path (blank = root)
• filterField · filterOperator · filterValue (Filter mode)
• sortDirection — Ascending / Descending
• limit · outputField (default items)

Run 2–4 downstream branches simultaneously and continue when all are dispatched.

• branches — active branch count (2–4, default 2)
• passInputToAll — clone the input to every branch

Wait for all parallel branches to finish, then emit a single merged result. Pairs with Fork.

• mergeMode — how to combine the branch outputs
• timeout — abort after N ms (0 = no timeout, default 30000)

Code-driven micro-flow with a tiny in-node OS. Author multiple JavaScript files, require() between them, and read/write IO ports with io.get / io.set.

• Custom IDE body — add or rename scripts (entry: main.js)
• Define your own input/output ports in the node config
• Optional embedded microflow with sub-projects + wires

Use when an Expression / Code node isn't enough — e.g. multi-file logic, helper modules, or building a reusable mini-component.

Real-time team messaging — post into channels, update threads, look up channel info.

• channel — #general or channel ID (C0123…)
• message — supports {{vars}} and Slack blocks
• messageTs — timestamp for updates

Use for: alerts · daily standups · AI replies in channels.

Bot/webhook messaging for Discord servers including rich embeds.

• channelId — Developer Mode → right-click channel → Copy ID
• message · embedTitle · embedDescription · embedColor
• limit — number of messages to fetch

Use for: community alerts · gaming bots · embed dashboards.

Microsoft Graph integration for chats, channels, teams, and meetings.

• chatId · teamId · channelId
• message — supports {{variables}}
• meetingSubject · meetingStart / meetingEnd (ISO 8601)

Bot API for channels, groups, and DMs.

• chatId — @channelName or numeric (-100…)
• text / caption · photoUrl
• parseMode — Markdown / HTML

WhatsApp Business / Cloud API for outbound messaging.

• to — E.164 format (e.g. +15551234567)
• message / templateName · mediaUrl
• mediaType — image / video / document

To send pure text (Send Message), the user has to message your WhatsApp Business number first, or already be inside the 24-hour customer service window. Meta does not let businesses start a conversation with arbitrary free-form text.

Outside that 24-hour window you must use an approved template (Send Template). Per Meta's docs, service / free-form messages can only be sent inside the customer service window; template messages are required outside it.

Typical flow:

1. Send the user a template, like hello_world (Send Template).
2. The user replies to that WhatsApp message.
3. Their reply opens the 24-hour customer service window.
4. During that window, your workflow can use Send Message to send normal text.

Free SMS via 20+ carrier email-to-SMS gateways — no Twilio required.

• phoneNumber — 10 digits
• carrier — Verizon · AT&T · T-Mobile · Sprint · Cricket · Boost · …
• message — keep under 160 chars per SMS

Push notifications to phones & desktops via the Pushover service.

• message · title
• priority — −2 (silent) … +2 (emergency)
• sound — pushover · bike · cosmic · siren …
• url + urlTitle

Customer-chat platform — manage conversations and people profiles.

• websiteId · sessionId
• messageContent · msgType — text / file / note
• peopleId · peopleEmail · peopleName

Conversational support platform — manage contacts, messages, conversations, notes, and tags.

• contactId · contactEmail · contactName
• messageBody · messageType — inapp / email
• conversationId · tagName

Read, send, search, and label messages in a connected Gmail account. Tokens auto-refresh.

• to · cc · bcc · subject · body
• query — Gmail search syntax (e.g. from:foo is:unread)
• labelIds — comma-separated label IDs

See GMAIL_INTEGRATION_GUIDE.md for setup.

Email + calendar via Microsoft Graph for personal & M365 accounts.

• to · cc · subject · body
• messageId · folderId
• filter — OData query · eventSubject · eventStart / eventEnd · attendees

Transactional email + contact list management at scale.

• to · from · subject
• body — HTML or plain text
• contactEmail · firstName · lastName

Newsletter + audience automation — manage members and campaigns.

• audienceId · email
• status — subscribed / unsubscribed / pending / cleaned
• mergeFields JSON · campaignId

List, fetch, search files; create folders; delete content.

Programmatic document editing — insert/replace text, batch updates.

• documentId · insertText + insertIndex
• searchText · replaceText
• batchRequests — raw Docs API JSON

Read/write cells in any spreadsheet using A1 notation.

• spreadsheetId
• range — A1 (e.g. Sheet1!A1:D10)
• values — 2D array JSON

Create presentations and replace template placeholders for automated decks.

• presentationId · slideId
• findText / replaceText (e.g. {{COMPANY_NAME}})
• imageUrl · matchCase

Create forms, list responses, and add questions programmatically.

List, create, update, and delete calendar events.

• calendarId — defaults to primary
• summary · description
• startDateTime / endDateTime (ISO 8601) · attendees (csv)

Create & manage Meet calls, retrieve recordings, list participants.

• summary · startDateTime / endDateTime
• attendees · meetingCode

Geocoding, routing, place search, and distance calculations.

• address · lat / lng
• origin · destination · travel mode (driving / walking / bicycling / transit)
• placeQuery · placeRadius · placeId

Run reports, real-time stats, and funnels against GA4 properties.

• propertyId · dateRangeStart / dateRangeEnd
• metrics & dimensions (csv)
• dimensionFilter JSON · funnelSteps JSON

Pages, databases, and search across your Notion workspace.

Full CRUD over Airtable bases.

Browse, upload, download, and search files in Dropbox.

• path — e.g. /reports/q4.pdf
• fileContent — Base64
• fileName · searchQuery

Self-hosted file storage — works with any Nextcloud server.

• serverUrl · path · destinationPath
• shareType — User · Group · Public Link · Email
• sharePermissions — read / update / create / delete / share

Generic file transfer for legacy / on-prem servers.

Personal & company profile actions, posts, and content reads.

• message · visibility — PUBLIC / CONNECTIONS
• companyId

Tweet, search, and look up users/timelines via the X API v2.

Profile / Page posting and reads via the Graph API.

Manage media, comments, insights, and hashtag content (Meta Graph).

Search videos and read channel/playlist content.

Browse subreddits, fetch posts & comments, post and comment.

Streams, channels, clips, top games, and chat.

Schedule posts to multiple social profiles in one shot.

• profileIds (csv) · postText
• scheduledAt (ISO 8601) · mediaUrl

Schedule posts, manage social profiles, view analytics.

• text · socialProfileIds (JSON array)
• scheduledTime (ISO 8601) · mediaUrls

Boards · lists · cards — full Kanban automation.

Issue tracking with JQL search and transitions.

Tasks, projects, sections, and workspaces.

Task automation with priorities, comments, and time tracking.

GraphQL-driven boards, items, columns, updates.

• boardId · itemId · itemName
• columnValues — JSON object keyed by column id

Manage CMS collections & items, publish sites.

Read scheduled events, list invitees, cancel meetings.

Contacts, deals, companies, and unified CRM search.

SOQL queries and full CRUD over Salesforce sObjects.

• soqlQuery · objectType · recordId
• createData / updateData (JSON)

Deals · persons · organizations.

Manage records across modules with search, conversion, and notes.

Customers, charges, payment intents, products, and invoices.

Use for: subscription billing · one-off payments · customer sync.

Products, orders, customers — full storefront automation.

Self-hosted WordPress shop integration.

Payments, orders, customers, catalog & locations.

Invoices, customers, payments, and SQL-like queries.

Cloud accounting — invoices, contacts, payments, bank txns.

Enterprise ERP — records, saved searches, SuiteQL.

Tickets, comments, users, organizations.

Tickets and contacts for the Freshdesk helpdesk.

Worker info, photos, reports, absence balances.

Employee directory, time-off requests, balances.

Event tracking, funnels, retention, user profiles.

Privacy-friendly web stats — aggregate, time-series, breakdowns.

Open-source web analytics — stats, pageviews, events.

Meetings, webinars, recordings, participants.

Meetings, messages, rooms, people.

Programmable SMS, MMS, WhatsApp, and voice calls.

• to · from — E.164
• body · mediaUrl (MMS)
• twimlUrl — for Make Call

AI phone calls — outbound, transcripts, analysis.

Voice agent platform — calls, assistants, phone numbers.

E-signature workflows — envelopes, recipients, templates.

Surveys, quizzes, and webhook subscriptions.

Generate text, CSV, PDF, or DOCX files from data with {{field}} placeholders.

Generate QR codes (PNG / SVG) — sized in pixels.

Cross-post articles to Medium and publications.

Create & export designs, manage assets & templates.

Files, nodes, images, components, comments.

Geocoding, directions, matrix, isochrones, static maps.

The most comprehensive connector — 70+ operations across REST + GraphQL.

Use for: CI/CD bots · auto-triage · release pipelines · code search.

Run Zapier actions and trigger Zaps from Verse workflows.

Generic REST caller — bring any API into your workflow using stored credentials.

Search the web (Tavily) and extract page contents — perfect for RAG & research agents.

• query · urls (newline-separated)
• maxResults · searchDepth (basic / advanced)
• includeAnswer · topic — general / news / finance

Pull updates from any RSS / Atom feed.

Built-in vector storage — ingest documents and retrieve by semantic similarity for RAG pipelines.

Drive a paired Versona desktop — execute agents, call tools, run code remotely.

See connect-versona-desktop-quickstart.md for setup.

Autonomous AI worker that uses Skill nodes as instructions and Tool Call nodes as capabilities.

• description — what the agent does; also used by orchestrators for routing
• systemPrompt — optional base instructions
• maxSteps (default 10) · timeout (default 120 seconds)

Named instruction block that feeds context, policy, or task knowledge into an Agent node.

• skillName — e.g. Customer Support or Data Analysis
• content — instructions or knowledge text the agent should follow

Wire its output into an Agent node’s skills input.

Wrap a Connector node and expose selected connector operations as callable tools for an Agent.

• toolName · toolDescription — optional LLM-facing overrides
• allowedOperations — comma-separated operation slugs; blank = all
• argDefaults — JSON defaults merged into every call
• customMode · toolType · config for custom functions

Connect a Connector node to connector, then wire out into an Agent’s tools input.

Route input to one of up to four sub-agents based on each agent’s description.

• description — orchestration strategy and routing criteria
• model — model used to choose a branch

Convert text into a vector embedding for semantic search, retrieval, clustering, or RAG workflows.

• inputField — text source, e.g. {{input.data.text}}
• localUrl · localModel for Local / Ollama
• outputField — default embedding

Classify input text into one of your labels and return both the category and confidence score.

• categories — comma-separated labels, e.g. positive, negative, neutral
• inputField — text to classify
• instructions — extra categorization guidance
• outputField — default classification

Define the final return value of the workflow, especially when it is called from chat or another workflow.

• responseType — output format returned to the caller
• template — response template, e.g. {"result": {{input.data}}}

Render an array as a formatted HTML table for reports, chat replies, and dashboard-like summaries.

• sourceField — array path, or blank for the root array
• columns · headers — comma-separated keys and display labels
• title · maxRows · outputField (default table)

Display the full incoming payload inline on the canvas so you can inspect exactly what flows through a wire.

• No fields — pass-through node with a custom body for live inspection.

Use before writing templates or variable paths; it reveals the real data shape.

Light up visually when data flows through a branch — useful for confirming IF, Switch, and parallel routes.

• ledColor — color picker (default #22c55e)
• label — visible route label, e.g. Route A active

Write a message to the workflow execution log while optionally passing data through to the next node.

• message — supports variables, e.g. Debug: {{input}}
• passthrough — keep data moving downstream (default true)

Add a documentation note to the canvas. It does not execute and has no ports.

• text — note body for documenting a workflow section
• noteColor · fontSize