Transform

The Transform node reshapes data from earlier workflow nodes and passes the result downstream. Use it when you need to extract fields, clean up API responses, filter or sort lists, keep only the fields another node needs, or prepare a payload for AI, Telegram, Discord, trading, or condition nodes.

Transform has two modes:

• Pipeline - the recommended visual editor. Pick an input and add ordered steps such as Filter, Sort, Slice, Project, Computed field, Literal field, and Age since.
• Template - a raw template expression for simple one-off reshaping or older workflows.

Configuration

Pipeline mode

Pipeline mode starts with the Input value, then runs each step in order. If Input is blank, the pipeline starts with the full upstream metadata object. If Input is {pumpfunResponse.data}, the pipeline starts with that field's value.

Most list-oriented steps expect the current value to be an array. A common pipeline is:

Input: {pumpfunResponse.data}
1. Filter
2. Sort
3. Slice
4. Project

Available steps

Filter operators

Filter rules can use:

• Comparison: =, ≠, <, ≤, >, ≥
• Text: contains, starts with, ends with, matches regex
• Membership: in list, not in list
• Existence: exists, is empty
• Age: younger or older than N seconds, minutes, hours, or days

Use nested groups for logic such as:

(status = live AND bondingProgressPct >= 80)
OR
(source in ["pumpfun", "birdeye"] AND age_hours < 6)

Example: select top Pump.fun tokens

Workflow:

Manual Trigger → Pump.fun → Transform → Telegram

Set the Pump.fun node result name to pumpfunResponse. In the Transform node:

1. Set Name this result to topTokens
2. Choose Pipeline mode
3. Set Input to:

{pumpfunResponse.data}

Add these steps:

A downstream Telegram node can then use:

Top token: {topTokens.data[0].symbol}
Mint: {topTokens.data[0].mint}
Progress: {topTokens.data[0].bondingProgressPct}%
Summary: {topTokens.data[0].summary}

Template mode

Template mode evaluates a raw expression against upstream node outputs. Use it for simple extraction or small string/JSON payloads.

Extract one field:

{birdeyeResponse.data.value}

Build a message string:

{jupiterResponse.data.inputMint} → {jupiterResponse.data.outputMint}: {jupiterResponse.data.outAmount}

Build a JSON object:

{
  "symbol": "{pumpfunResponse.data[0].symbol}",
  "mint": "{pumpfunResponse.data[0].mint}",
  "progress": "{pumpfunResponse.data[0].bondingProgressPct}"
}

If the entire expression is a single {path} that resolves to an array or object, Transform returns the native value directly - no String(value) coercion that would otherwise turn an array into "[object Object],...". For mixed templates and primitive paths, the rendered template is parsed as JSON when it's valid (so "42" becomes the number 42); otherwise it stays a string.

Output

A successful Transform node returns:

{
  "success": true,
  "data": "<transformed result>"
}

Downstream nodes read the transformed value under .data.

If Name this result is topTokens:

{topTokens.data}
{topTokens.data[0].symbol}

Set a result name whenever another node needs to reference this Transform. If no friendly name is set, use the variable hints in downstream text fields to insert the available node-id path.

Previewing

Transform settings use the shared node-settings layout:

• Input shows the upstream sample available to the Transform. The default Variables view is best for finding fields; switch to JSON, Schema, or Table for exact inspection.
• Parameters contains the Transform mode, input field, and pipeline/template editor.
• Output shows a Live preview for the current draft and a Last tab for the most recent persisted run output.

When upstream sample data is available, the Live preview runs the same pipeline/template interpreter used by production workflow runs, so the preview should match runtime behavior. It updates as you edit the Transform draft.

If there is no sample yet, use the Input pane button to execute previous nodes. This runs the nodes before the Transform and uses their latest outputs as preview data. Preview runs count as one monthly run and are hidden from normal execution history. If upstream nodes can send messages, transfer funds, trade, or broadcast transactions, the editor asks for confirmation before firing them.

Clicking values in the Input pane inserts template paths into Transform fields when possible. Use {json ...} when the value is an object or array and the receiving field expects valid JSON text.

Limits and safety

• Pipeline output is capped at 5 MB.
• Array-processing steps are capped at 100,000 items.
• Field paths use dot notation such as token.holders.count.
• Field paths cannot be empty, start/end with ., contain doubled dots, or use reserved prototype segments such as __proto__, constructor, or prototype.
• Filter, Sort, Slice, and per-item Project/Computed/Literal/Age steps require the current pipeline value to be an array.
• Literal field values must be JSON-serializable.
• Age filters and Age since read the current time; other pipeline steps are deterministic for the same input.

When to use Transform vs Code

Use Transform when your data change fits the visual steps: filter, sort, slice, project, rename, add fixed fields, add template-derived fields, or compute ages.

Use Code when you need arbitrary JavaScript, such as custom math, grouping, complex scoring, reducing an array into a summary object, or handling inconsistent data shapes that do not fit the visual pipeline.

Next steps

• Code - run custom JavaScript when the visual pipeline is not expressive enough
• Configuring Nodes - input/output panes and variables
• Filter - conditionally pass or block a workflow path
• Condition - multi-path branching