Node Types

Both fields hold the same ISO timestamp, set when the scheduled run starts.

"trigger": { "type": "schedule", "cron": "0 9 * * 1-5", "timezone": "Europe/London" }

Each message starts a run of every enabled workflow you own with a telegram trigger. Bot commands such as /start and /help are handled by the bot instead. Deploying starts one run with empty trigger data unless you send "autoRun": false.

"trigger": { "type": "telegram" }

JSON responses are parsed into body; other text is cut at 4096 characters. Binary responses (images, video, audio, PDF, archives) are stored as a temporary file and return fileUrl, fileName, mimeType, sizeBytes and expiresAt instead of body. A non-2xx response fails the step with HTTP_<status>. An optional credential is injected as authentication.

{
  "ref": "create_contact",
  "action": "http",
  "config": {
    "url": "https://api.example.com/contacts",
    "method": "POST",
    "headers": { "Content-Type": "application/json" },
    "body": { "email": "{{trigger.output.body.email}}" },
    "timeoutMs": 10000
  }
}

Output: The template with every expression resolved. An expression that points at an object or array is inserted as JSON text.

{
  "ref": "format",
  "action": "transform",
  "config": {
    "template": {
      "message": "Hello, {{trigger.output.body.name}}!",
      "received": "{{trigger.output.receivedAt}}"
    }
  }
}

The code can read steps (earlier outputs by ref), trigger (the trigger output) and input (this step's config), and can call fetch on public addresses. It has no access to Node.js modules and times out after 30 seconds. Output: a returned object or array as-is; other values as { value }.

{
  "ref": "count_orders",
  "action": "code",
  "config": {
    "expression": "const orders = trigger.body.orders || []; return { count: orders.length };"
  }
}

Output: an array result as { result, count }; an object result as-is; any other result as { result }. Up to 100,000 items.

{
  "ref": "big_orders",
  "action": "filter",
  "config": {
    "arrayExpression": "{{trigger.output.body.orders}}",
    "condition": "item.total > 100",
    "mode": "filter"
  }
}

That is the SMTP output; the other providers return { messageId, provider, status }.

Requires credential: smtp

Requires credential: slack

Requires credential: discord

That is the send_message output. send_photo, send_document and forward_message return { messageId, chatId, action } (forward_message adds fromChatId); get_updates returns { updates, updateCount, action }.

Requires credential: telegram

Auto-chunking: With send_message, text longer than 4096 characters is split, at a newline where possible, and sent as several messages.

Requires credential: imap

Requires credential: twitter

For read_rows, append_row and update_cell respectively.

Requires credential: google

Output: list { fileCount, files }; upload { fileId, name, mimeType }; download returns the file as text { contentLength, content, wasTruncated } (up to 65,536 characters); download_media stores binary content as a temporary file { fileUrl, fileName, mimeType, sizeBytes, expiresAt }.

Requires credential: google

Requires credential: google

Requires credential: database

Extra output fields: json (responseFormat json or outputSchema), schemaValid (with outputSchema), toolCalls (every tool call with its arguments and result), toolCall (outside agent mode, when there was exactly one call), and totalIterations (agent mode). The step needs no credential; it uses the install's LLM settings.

{
  "ref": "research",
  "action": "ai",
  "config": {
    "systemPrompt": "You are a careful research assistant.",
    "prompt": "Find the pricing page of {{trigger.output.payload.domain}} and list its plans as JSON.",
    "responseFormat": "json",
    "agentMode": true,
    "maxIterations": 8,
    "memoryEnabled": true
  }
}

{
  "ref": "classify",
  "action": "ai",
  "config": {
    "prompt": "Classify this support message: {{trigger.output.body.text}}",
    "outputSchema": {
      "type": "object",
      "properties": {
        "category": { "type": "string", "enum": ["billing", "bug", "other"] },
        "urgent": { "type": "boolean" }
      },
      "required": ["category", "urgent"]
    }
  }
}

S6S sends initialize and then tools/call, without authentication headers. Replies may be JSON or an event stream. With the older transport, S6S opens the event stream at serverUrl and posts to the endpoint it names, which must be on the same origin. transport in the output says which one ran. result is the tool's text output, parsed as JSON when possible. A JSON-RPC error fails the step with MCP_TOOL_ERROR.

{
  "ref": "lookup_issue",
  "action": "mcp_tool",
  "config": {
    "serverUrl": "https://mcp.example.com/mcp",
    "toolName": "get_issue",
    "arguments": { "id": "{{trigger.output.payload.issue_id}}" },
    "timeoutMs": 20000
  }
}

Status: the schema and the deploy API accept this node, but no vector store is connected in this release. The step embeds the query with the install's LLM key and then fails with RAG_NO_VECTOR_STORE (or RAG_NO_API_KEY when no key is set).

Output: create_post { postIds, postId, count, scheduledAt, errors? }; list_channels { channels, channelCount }; get_queue and get_sent { updates, updateCount, total }; share_now { success, updateId }; delete_post { deleted, updateId }; update_post { postId, status, text, scheduledAt }.

Requires credential: buffer

Output: list_videos { videos, resultCount }; the other actions { videoId, url, status, title }, plus channelId for upload_video and get_video.

Requires credential: google

This does not change the HTTP reply to the webhook caller. That reply is sent as soon as the run is created and contains the run ID and trigger data.

result holds the child run and its steps. Without waiting, the output is { triggered, runId, workflowSlug }. A failed or cancelled child run fails this step; so does running out of wait time (EXECUTE_WORKFLOW_TIMEOUT).

{
  "ref": "run_child",
  "action": "execute_workflow",
  "config": {
    "slug": "enrich-lead",
    "input": { "email": "{{trigger.output.body.email}}" },
    "waitForCompletion": true,
    "maxWaitMs": 120000
  }
}

Usually combined with run_if so it only fires when a check fails.

eq, neq, contains and not_contains compare as text. gt, gte, lt and lte compare as numbers (an empty value counts as 0) and are false if either side isn't numeric. matches takes a regular expression; in takes an array or a comma-separated list. exists is true when the field the expression names is set (an empty string, 0 and false count as set) and false when it is missing or null; not_exists is the opposite. For a template that mixes text or several fields, exists means its text is not empty.

Raw IR also accepts a compound form, { logic: "and" | "or", conditions }: and needs every condition to hold, or any one, and a condition can itself be compound (up to 10 levels). Its output has logic in place of operator and compareValue, and resolvedValue reads compound(and) or compound(or). Recipes take one comparison per condition step.

{
  "name": "Check Order Size",
  "trigger": { "type": "manual" },
  "steps": [
    {
      "ref": "is_large",
      "action": "condition",
      "config": {
        "expression": "{{trigger.output.payload.total}}",
        "operator": "gt",
        "value": 1000
      }
    },
    {
      "ref": "large_order",
      "action": "transform",
      "config": { "template": { "size": "large" } }
    },
    {
      "ref": "small_order",
      "action": "transform",
      "config": { "template": { "size": "small" } }
    }
  ],
  "flow": [["is_large", "large_order", "small_order"]]
}

Values are compared as text. The matching step runs; the other targets and the steps that only follow them are skipped. With no match and no default, all targets are skipped. Put the targets after the switch in the flow, usually as one parallel group.

{
  "name": "Route Ticket",
  "trigger": { "type": "manual" },
  "steps": [
    {
      "ref": "route",
      "action": "switch",
      "config": {
        "expression": "{{trigger.output.payload.priority}}",
        "cases": [
          { "value": "high", "target_ref": "page_oncall" },
          { "value": "low", "target_ref": "log_ticket" }
        ],
        "defaultTarget": "log_ticket"
      }
    },
    {
      "ref": "page_oncall",
      "action": "transform",
      "config": { "template": { "action": "page" } }
    },
    {
      "ref": "log_ticket",
      "action": "transform",
      "config": { "template": { "action": "log" } }
    }
  ],
  "flow": ["route", ["page_oncall", "log_ticket"]]
}

The loop does not run later steps once per item. To process each item, use action.filter (map mode) or action.code.

{
  "name": "Fetch Two Sources",
  "trigger": { "type": "manual" },
  "steps": [
    {
      "ref": "branch_a",
      "action": "http",
      "config": { "url": "https://api.example.com/a", "method": "GET" }
    },
    {
      "ref": "branch_b",
      "action": "http",
      "config": { "url": "https://api.example.com/b", "method": "GET" }
    },
    {
      "ref": "combine",
      "action": "merge",
      "config": {}
    },
    {
      "ref": "send_result",
      "action": "transform",
      "config": {
        "template": {
          "a_status": "{{combine.output.branch_a.status}}",
          "b_status": "{{combine.output.branch_b.status}}"
        }
      }
    }
  ],
  "flow": [["branch_a", "branch_b"], "combine", "send_result"]
}

combine waits for both parallel steps and outputs their results keyed by ref.