> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flowx.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Token

> Token represents the current position in the process flow. When you start a process, you have a graph of nodes that connect based on the defined sequence and configuration.

The token is a [BPMN](../platform-overview/frameworks-and-standards/business-process-industry-standards/intro-to-bpmn) concept that represents a state within a process instance. It keeps track of the current position in the process flow and is used to store data related to the current process instance state.

A token is created each time a new process instance starts. As actions on the process instance execute, the token advances from one node to the next. Because a node can have several [actions](./actions/actions) that need execution, the token also tracks the actions executed in each node.

<Tip>
  For [parallel gateways](./node/parallel-gateway), child tokens are created for each flow branch. The parent token moves to the gateway sync node and advances only after all child tokens reach that node.
</Tip>

The following diagram shows how a token advances through a process flow:

<Frame title="Token flow diagram" caption="A token advances through a process flow">
  ![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/5.x/flowx-token-flow-diagram.svg)
</Frame>

The token moves to the next node only after all mandatory actions from the current node are executed. The token also waits on a node if the node is configured to receive an event from an external system through Kafka.

<Tip>
  Sometimes the token stops at a node until user input is received. If user input is required to advance the process, the token advances only after all data is received. Use a mandatory manual action linked to the user action to ensure the process flow advances only after the user input is received.
</Tip>

## Viewing tokens

Retrieve the current process instance status using the FlowX Designer. The Designer displays information about tokens related to that process instance and the current nodes they are in.

![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/5.x/token_view.png)

### Token view table

The token view displays tokens in a **tree table** format, providing a hierarchical view of parent and child tokens. This format is especially useful when working with parallel gateways or embedded subprocesses.

<Info>
  If parallel gateways are configured in a process, multiple tokens are created, one for each parallel path.

  ![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/5.x/parallel_tokens.png)
</Info>

#### Token view features

<CardGroup cols={2}>
  <Card title="Tree structure" icon="sitemap">
    Tokens are displayed hierarchically, showing parent-child relationships. All rows are expanded by default.
  </Card>

  <Card title="Horizontal scrolling" icon="arrows-left-right">
    The table supports horizontal scrolling to accommodate all columns
  </Card>

  <Card title="Frozen columns" icon="grip-vertical">
    The UUID and Actions columns remain fixed when scrolling horizontally for constant visibility
  </Card>

  <Card title="Tooltips" icon="info">
    Long names are truncated with tooltips showing the full text on hover
  </Card>
</CardGroup>

The token view table includes the following columns:

| Column                  | Description                                                                                                                                                                                                                                    |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **UUID**                | Unique identifier for the token. Only the first 6 characters are displayed with a copy icon. Clicking the icon copies the full UUID to clipboard. **Frozen column** (stays visible during horizontal scroll)                                   |
| **Token Status**        | Current state of the token in the process (ACTIVE, INACTIVE, ABORTED, ON HOLD, DISMISSED, EXPIRED, or TERMINATED). Displayed as color-coded tags                                                                                               |
| **Context**             | Shows the main process name for tokens in the main process, or the embedded subprocess name for tokens running within embedded subprocesses (any nesting level)                                                                                |
| **Initiator Node**      | The node or event that initiated the token (for example, Parallel Gateway, Non-interrupting boundary event). Applies to child tokens only; displays "-" for parent tokens                                                                      |
| **First Executed Node** | The node where the token first executed. For parallel gateway tokens, shows the first executed node on that parallel branch. For boundary event tokens, shows the first executed node on the branch started from the boundary node             |
| **Current Node**        | The node where the token is currently positioned. For tokens in embedded subprocesses, displays the current node from the subprocess                                                                                                           |
| **Current Node Status** | The token's status within the current node (ARRIVED, EXECUTING, EXECUTED\_COMPLETE, EXECUTED\_PARTIAL, WAITING\_MESSAGE\_EVENT, WAITING\_TIMER\_EVENT, WAITING\_MESSAGE, MESSAGE\_RECEIVED, or MESSAGE\_RESPONSE\_TIMED\_OUT). Sortable column |
| **Last updated**        | The date and time when the token was last updated. Displays full datetime in browser timezone                                                                                                                                                  |
| **Actions**             | Available actions including Retry (only visible for ACTIVE tokens) and View details (eye icon). **Frozen column** (stays visible during horizontal scroll)                                                                                     |

<Frame>
  ![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/5.x/token_status_cn.png)
</Frame>

## Understanding token status

### Token status values

The token status indicates the lifecycle state of a token in the process:

<AccordionGroup>
  <Accordion title="ACTIVE" icon="circle-check">
    Token state is active when tokens are created. A parent token reactivates when all child tokens reach the parallel gateway closing node.
  </Accordion>

  <Accordion title="INACTIVE" icon="circle-pause">
    Child tokens become inactive when they arrive at a parallel gateway closing node. The current token becomes inactive when it reaches a final node.
  </Accordion>

  <Accordion title="ABORTED" icon="circle-xmark">
    The current token becomes aborted when it moves backward to redo a series of previous actions in the process. The token resets, and a new token activates.
  </Accordion>

  <Accordion title="ON HOLD" icon="circle-pause">
    When a parallel split gateway node is reached, the parent token is set to On hold until all child tokens reach the parallel gateway closing node. The parent token does not have a "Retry" action icon until all child tokens finish.
  </Accordion>

  <Accordion title="DISMISSED" icon="circle-minus">
    The process or subprocess reaches a certain node and is canceled or exited.
  </Accordion>

  <Accordion title="EXPIRED" icon="clock">
    A defined "expiryTime" in the process definition passes, and the token changes to this status.
  </Accordion>

  <Accordion title="TERMINATED" icon="ban">
    The process is terminated by a termination request.
  </Accordion>
</AccordionGroup>

### Current node status values

The current node status indicates the execution status of the token within its current node:

<AccordionGroup>
  <Accordion title="ARRIVED" icon="location-dot">
    The token reaches a new node
  </Accordion>

  <Accordion title="EXECUTING" icon="play">
    The token execution starts
  </Accordion>

  <Accordion title="EXECUTED_COMPLETE" icon="circle-check">
    Node actions execute, and all mandatory actions from the node complete
  </Accordion>

  <Accordion title="EXECUTED_PARTIAL" icon="circle-half-stroke">
    Node actions execute, but mandatory uncompleted actions remain
  </Accordion>

  <Accordion title="WAITING_MESSAGE_EVENT" icon="envelope">
    The token reaches an intermediate message catch event node
  </Accordion>

  <Accordion title="WAITING_TIMER_EVENT" icon="clock">
    The token reaches an intermediate timer event node
  </Accordion>

  <Accordion title="WAITING_MESSAGE" icon="hourglass-half">
    The token waits for a message from another system
  </Accordion>

  <Accordion title="MESSAGE_RECEIVED" icon="check">
    The message is received
  </Accordion>

  <Accordion title="MESSAGE_RESPONSE_TIMED_OUT" icon="triangle-exclamation">
    The message is not received within the set timeframe
  </Accordion>
</AccordionGroup>

### Initiator types

Tokens can be initiated by different sources. The initiator information is displayed in the **Initiator Node** column of the token view:

<CardGroup cols={2}>
  <Card title="START_EVENT" icon="play">
    Token initiated by a process start event. Parent tokens display "-" in the Initiator Node column.
  </Card>

  <Card title="BOUNDARY_EVENT" icon="clock">
    Token initiated by a boundary event (for example, timer or message boundary event). The boundary event node name is displayed in the Initiator Node column.
  </Card>

  <Card title="PARALLEL_GATEWAY" icon="code-branch">
    Child token created by a parallel split gateway. The parallel gateway node name is displayed in the Initiator Node column.
  </Card>

  <Card title="SUBPROCESS" icon="layer-group">
    Token created for an embedded subprocess execution.
  </Card>
</CardGroup>

<Info>
  For tokens initiated by a **BOUNDARY\_EVENT** within an embedded subprocess, the token context is preserved and the initiator node name is correctly mapped in the token view.
</Info>

### Viewing token details

To view more details about a token:

<Steps>
  <Step title="Open Process status">
    Click the **Process status** view button in the FlowX Designer.
  </Step>

  <Step title="Select a token">
    Select a token from the token list.
  </Step>

  <Step title="View details">
    Click the **view button** (eye icon) to open the detailed token status view.
  </Step>
</Steps>

Access the detailed token status view by navigating to Process instance → Tokens → View (eye icon). The detailed token status modal displays comprehensive information about the token's current state, execution history, and configuration in a structured key-value format.

<Frame title="Token status modal" caption="Detailed token status view showing token information, node details, and execution states">
  ![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/5.x/token_status.png)
</Frame>

The detailed token status view presents token information in an expandable JSON-like structure. Key identifiers and status values are highlighted for quick identification. The modal includes the following fields organized by category:

<AccordionGroup>
  <Accordion title="Token identification" icon="fingerprint">
    * **id**: The unique identifier of the token
    * **version**: The version number of the token schema
    * **parentTokenId**: The identifier of the parent token (present for child tokens created by parallel gateways or subprocesses)
    * **processInstanceId**: The identifier of the process instance this token belongs to
  </Accordion>

  <Accordion title="Token state" icon="circle-info">
    * **state**: The current lifecycle state of the token (see [Token status values](#token-status-values) for details)
    * **statusCurrentNode**: The execution status of the token within its current node (see [Current node status values](#current-node-status-values) for details)
    * **dateUpdated**: The ISO 8601 timestamp indicating when the token was last updated
  </Accordion>

  <Accordion title="Node information" icon="diagram-project">
    * **startNodeId**: The identifier of the node where the token execution began
    * **currentNodeId**: The identifier of the node where the token is currently positioned
    * **currentNodeName**: The human-readable name of the current node
    * **currentNode**: Detailed information about the current node object
    * **embedNodeId**: The identifier of the embedded node, if the token is executing within an embedded subprocess
    * **mainSwimlaneId**: The identifier of the main swimlane associated with the token
  </Accordion>

  <Accordion title="Process context" icon="sitemap">
    * **currentProcessVersionId**: The identifier of the process version currently being executed
    * **currentContext**: The current execution context (typically "main" for the main process, or the subprocess name for embedded subprocesses). This corresponds to the **Context** column in the token view table.
  </Accordion>

  <Accordion title="Initiator information" icon="play">
    * **initiatorType**: The type of initiator that created this token (see [Initiator types](#initiator-types) for details)
    * **initiatorId**: The identifier of the initiator node or event
    * **initiatorNode**: The name of the node that initiated the token. This corresponds to the **Initiator Node** column in the token view table.
  </Accordion>

  <Accordion title="Synchronization" icon="sync">
    * **syncNodeTokensCount**: The total number of synchronized node tokens (used for parallel gateway synchronization)
    * **syncNodeTokensFinished**: The count of synchronized node tokens that have finished execution
  </Accordion>

  <Accordion title="Execution history" icon="history">
    * **nodesActionStates**: An expandable array containing detailed information about the action states for each node the token has visited. Each entry includes:
      * **nodeId**: The identifier of the node
      * **context**: The execution context (main or subprocess name)
      * **embedNodeId**: The embedded node identifier, if applicable
      * **name**: The name of the node
    * **backSeq**: An expandable object containing backward sequence information for tokens that have moved backward in the process flow:
      * **nodesSeq**: An array of node sequences that were executed in reverse order
      * **uuid**: The unique identifier for the backward sequence
      * **context**: The context where the backward sequence occurred
      * **initiatorNode**: The name of the node that initiated the backward sequence
      * **firstExecutedNode**: The first node executed in the backward sequence
      * **currentNode**: The current node in the backward sequence
  </Accordion>

  <Accordion title="Additional data" icon="database">
    * **paramValues**: Parameter values and process variables associated with the token
  </Accordion>
</AccordionGroup>

<Info>
  The **nodesActionStates** and **backSeq** sections are expandable in the detailed token status view. Expand these sections to view comprehensive information about node execution history and backward sequence tracking.
</Info>