All Products
Search
Document Center

Security Center:Component parameters and node execution flow

Last Updated:Mar 31, 2026

SOAR playbook nodes accept four kinds of parameter values — constants, variables, expressions, and functions — and process them through a three-stage execution pipeline: extraction, deduplication, and action execution. This page explains each parameter type, the syntax for referencing upstream node outputs, data-type conversion rules, and how the pipeline works end to end.

Parameter categories

Parameters fall into two classification dimensions:

  • By role: playbook input parameters, playbook output parameters, component action input parameters, and component action output parameters.

  • By source: system parameters and component parameters.

System parameters are accessible from any node during execution. Component parameters are not.

Node input and output parameters

A node's input can be a fixed (constant) value or the output of an upstream node. To reference an upstream node's output, that node must appear before the current node on the same orchestration path.

Important

In multi-path playbooks, node names must be globally unique.

The following diagram illustrates the rule. Node B can access the outputs of Node A (a direct upstream) and the playbook's input parameters. It cannot access Node D (a different branch) or Node C (not a preceding node of Node B on any path).

image

System parameters

Playbook-level system parameters

Use ${event.parameter_name} to access these parameters from any node. event is the reserved name of the start node; do not name any component event during playbook orchestration.

ParameterData typeExpressionDescription
_tenant_idString${event._tenant_id}Alibaba Cloud account ID that calls the playbook
_domain_idString${event._domain_id}Role status of the logged-on user: 0 = single-account, 1 = global account
_trigger_userString${event._trigger_user}Alibaba Cloud account ID that triggers the playbook. If a RAM user triggers the playbook, the RAM user's ID is returned.
_region_idString${event._region_id}Region ID
_req_uuidString${event._req_uuid}Unique identifier for the current playbook execution
parentTaskUuidString${event.parentTaskUuid}_req_uuid of the parent playbook. Present only when this playbook is called as a child playbook.
parentTaskNameString${event.parentTaskName}UUID of the parent playbook. Present only when this playbook is called as a child playbook.

Component action output parameters

Every node execution produces the following standard output fields. Custom output parameters from the component are stored inside datalist. Use ${node_name.datalist.*} to retrieve all output values.

ParameterData typeDescription
datalistJSONArrayOutput parameters produced by the action. Custom component outputs are also stored here.
total_data_successfulIntNumber of data entries successfully processed
total_dataIntTotal number of data entries processed
total_data_with_dupIntThe volume of data that is successfully processed and deduplicated during the action execution
total_exe_successfulIntNumber of times the action completed successfully
total_exeIntTotal number of times the action ran
statusBooleanExecution status: true (success) or false (failure)
messageForUserStringError message shown to the user if the action fails
messageStringInternal system error message if the action fails
failed_exe_detailStringDetailed error information if the action fails

Parameter formats

Node input parameters support three basic formats — constants, variables, and expressions — and any combination of them.

FormatDescriptionExample
ConstantA fixed string valueAli
VariableExtracts a value from playbook input parameters or an upstream node's output${event.aliuid}
ExpressionEvaluates an embedded Java expression or built-in function. Format: <%=expression%><%=2*60*60%>, <%=currentTime()%>
CombinationMixes constants, variables, and expressions in a single stringAli_${event.aliuid}_<%=currentTime()%>_<%=2*60*60%> resolves to Ali_<aliuid>_<timestamp>_7200

Expressions can also embed variables. For example:

<%=formatTimeStamp(secondstamp_add(${DateTime:event.datalist.*.gmt_create},-600L),"yyyy-MM-dd'T'HH:mm:ss.SSSXXX")%>

This reads gmt_create from the start node output, subtracts 600 seconds, and formats the result as an ISO 8601 timestamp.

Built-in functions

All expressions use Java syntax. Functions are grouped by category below.

Time functions

FunctionDescriptionExampleOutput
currentTime()Returns the current timestamp<%=currentTime()%>2025-06-05 10:30:00
currentTimeToMs()Returns the current timestamp in milliseconds<%=currentTimeToMs()%>1749091369688
currentHourToMs()Returns the millisecond timestamp for the start of the current hour<%=currentHourToMs()%>1749088800000
currentDayToMs()Returns the millisecond timestamp for the start of the current day<%=currentDayToMs()%>1749052800000
secondstamp_add(timestamp, seconds)Adds a number of seconds to a timestamp<%=secondstamp_add(currentTime(),300L)%>2025-06-05 10:35:00
timestampToseconds(timestamp, seconds)Adds seconds to a timestamp, then converts to epoch seconds<%=timestampToseconds(currentTime(),300L)%>1749099848
formatTimeStamp(timestamp, format)Formats a timestamp using a Java date pattern<%=formatTimeStamp(currentTime(),"yyyyMMdd")%>20250605
parseTimeMs(timeStr, format)Parses a formatted time string and returns milliseconds<%=parseTimeMs("2025-06-05 10:30:32","yyyy-MM-ddHH:mm:ss")%>1749090632000
parseTimeMsWDefault(timeStr, defaultMs)Parses a time string to milliseconds; returns defaultMs if the input is empty<%=parseTimeMsWDefault("2025-06-05 10:30:32",1749091369688L)%>1749090632000

String functions

FunctionDescriptionExampleOutput
toLowerCase(str)Converts a string to lowercase<%=toLowerCase("TEST")%>test
toUpperCase(str)Converts a string to uppercase<%=toUpperCase("test")%>TEST
substring(str, start, end)Extracts a substring by start and end index<%=substring("012345",0,3)%>012
remainStrStartEnd(str, beginSize, endSize)Keeps the first beginSize and last endSize characters, joined by _____<%=remainStrStartEnd("012345",2,2)%>01_____45
replace(str, target, replacement)Replaces a substring<%=replace("abc123","abc","aaa")%>aaa123
splitStr(str, delimiter)Splits a string into a list by a delimiter<%=splitStr("test,value",",")%>[test,value]
splitStrToJsonArray(str, delimiter)Splits a string into a JSONArray by a delimiter<%=splitStrToJsonArray("test,value",",")%>["test","value"]
concatListStr(delimiter, list)Concatenates list elements with a delimiter. Use with splitStr.<%=concatListStr("|",splitStr("test,value",","))%>test|value

Type conversion and utility functions

FunctionDescriptionExampleOutput
toLong(value, default)Converts a value to Long; returns default if conversion fails<%=toLong("1234",12L)%>1234.0
toJSONObject(jsonStr)Parses a JSON string into a JSONObject<%=toJSONObject("{\"name\":\"test\",\"age\":12}")%>{"name":"test","age":12}
base64encode(str)Encodes a string using Base64<%=base64encode("abc")%>YWJj
base64decode(str)Decodes a Base64 string<%=base64decode("YWJj")%>abc
isNull(value)Returns true if the value is null or empty<%=isNull("")%>true

Variable parameters

Use the ${node_name.parameter_path} syntax to reference any preceding node's output. The path follows JSONPath conventions and supports JSON structures of any depth.

Important
  • Variables can only reference output parameters of a node, not its inputs.

  • Playbook input parameters equal the start node's output parameters.

  • The input parameters of the current node are the same as the output parameters of the previous node.

  • event is the reserved name for the start node. Do not name any component event.

Reference syntax

The examples below all use the following node1 output as the data source:

{
  "datalist": [
    { "person": { "weight": "120", "age": "12" } },
    { "person": { "weight": "121", "age": "13" } }
  ],
  "total_data_successful": 2,
  "total_data": 2,
  "total_exe_successful": 2,
  "total_exe": 2,
  "total_data_with_dup": 2,
  "status": true
}
PatternSyntaxResult
Get a system parameter from the start node${event._req_uuid}Unique ID of the current execution
Get a parent playbook's UUID${event.parentTaskUuid}Parent's _req_uuid (child playbooks only)
Get a scalar field from a node${node1.total_data_successful}2
Get a field from all items in datalist${node1.datalist.*.person.age}{12,13}
Get a field from the first item in datalist${node1.datalist.[0].person.age}12
Get all values in a nested array field${node_name.datalist.*.parameter1.*.parameter2}All parameter2 values where parameter1 is a JSONArray

For datalist-based paths, * means all items; [0] means the first item. The start node uses event instead of a node name: ${event.parameter1.parameter2}.

Tip: Instead of writing variable syntax manually, use the parameter drop-down selector in the input box to generate the correct path after you finish testing.
image

Data type conversion

During playbook execution, most data is handled as strings. When an action requires a specific type, use ${data_type:data} to convert.

Target typeDescriptionSupported source types
BooleanConverts to true or falseNumeric: 1true, all other values → false. String: "true", "1", "Y", "T"true; "false", "0", "N", "F"false. Other strings cause an error.
LongConverts to a Long integerNumeric types; strings containing only digits and commas (e.g., 1,000,000)
IntConverts to an integerNumeric types
DoubleConverts to a double-precision floatNumeric types
StringConverts to a stringAll types
DateTimeConverts to a dateNumeric types; strings that are numeric (e.g., 1696487400000) or in ISO 8601 format (e.g., 2023-10-05 14:30:00)
JSONObjectExtracts key-value pairs from a JSONObject into a new JSONObject. Output format: {"fieldname":"fieldValue",...}JSONObject only
JSONArrayExtracts key-value pairs from a JSONObject into a JSONArray. Output format: [{"fieldname":"fieldValue",...}]JSONObject only
JSONObjectStrConverts a JSONObject to its string representationJSONObject
JSONArrayStrConverts a JSONArray to its string representationJSONArray

Examples

The following examples use the same node1 output defined in the Reference syntax section.

Input (single JSONObject): {"src_ip":"127.0.0.1","dst_ip":"127.0.0.2","msg":"hello"}

ExpressionResult
${JSONObject:event}The entire event as a JSON string
${JSONObject:event.src_ip}{"src_ip":"127.0.0.1"}
${JSONObject:event.src_ip|msg}{"src_ip":"127.0.0.1","msg":"hello"}
${JSONArray:event}The entire event as a JSONArray
${JSONArray:event.src_ip}[{"src_ip":"127.22.22.1"}]
${JSONArray:event.src_ip|msg}[{"src_ip":"127.0.0.1","msg":"hello"}]

Input (JSONArray in datalist): {"datalist":[{"src_ip":"127.0.0.1","dst_ip":"127.1.0.1","msg":"hello"},{"src_ip":"127.1.0.1","dst_ip":"127.1.0.1","msg":"hello"}]}

ExpressionResult
${JSONObject:event.datalist.*.src_ip}Expands to multiple rows; each row: {"src_ip":"127.x.0.1"}
${JSONObject:event.datalist.*.src_ip|msg}Expands to multiple rows; each row: {"src_ip":"127.x.0.1","msg":"hello"}
${JSONArray:event.datalist.*.src_ip}[{"src_ip":"127.0.0.1"},{"src_ip":"127.1.0.1"}]
${JSONArray:event.datalist.*.src_ip|msg}[{"src_ip":"127.0.0.1","msg":"hello"},{"src_ip":"127.1.0.1","msg":"hello"}]

Parameter processing and node execution flow

image

Each node goes through three stages after all required upstream nodes finish executing.

Stage 1: Extract input parameters

The system resolves the node's input configuration against the actual outputs of upstream nodes and the playbook's input parameters to produce one or more sets of concrete input values.

Stage 2: Deduplicate and execute

If the resolved input produces multiple identical parameter sets, the system deduplicates them before execution. The action then runs once for each unique parameter set.

When an input expression resolves to multiple values (for example, ${node1.datalist.*.ip} matching five IP addresses), the action runs once per value automatically. No loop logic is needed in the playbook. Example: To run "Purge Malicious File" on all servers of a compromised application, set the Server IP parameter to ${node1.datalist.*.ip}. The system executes the action on each IP address without any additional configuration.

Stage 3: Aggregate and deduplicate output

Results from all action executions are merged into a single output. The system deduplicates entries where every field is identical.

Example:

Before deduplicationAfter deduplication
[{"a":"11","b":"22"},{"a":"11","b":"22"},{"a":"11","b":"33"}][{"a":"11","b":"22"},{"a":"11","b":"33"}]

Parameter extraction rules

Single data source

A JSON structure of any depth is treated as a tree. Extraction follows these rules:

  1. Any depth: Data is extracted regardless of how deeply it is nested.

    image

  2. Sibling relationships are preserved: Fields at the same level in the JSON structure remain paired.

    image

  3. Ancestor nodes are expanded: When a parent node has multiple children, it expands to match the child count.

    image

  4. Non-sibling, non-ancestor nodes form a Cartesian product: When two fields have no sibling or ancestor relationship, every combination is produced.

    image

Multiple data sources

When a node references parameters from multiple upstream nodes, the system applies a Cartesian product across the extraction results of each source.

image