> ## 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.

# Start process from UI with resource definition and inherit values

> Start a process by resource definition ID and inherit parameter values from a related process instance. Typically used from event handlers.

<Tip>
  Looking for end-to-end guidance on calling FlowX from your own app? See [Consuming FlowX from external apps](/5.9/docs/platform-deep-dive/integrations/consuming-flowx-from-external-apps).
</Tip>

## Base URL

* Always prepend the endpoint with the correct Base URL for your environment.
* For different environments (like staging or production), switch the base URL accordingly.

## Path Parameters

<Info>
  **Need help finding these IDs?** See the [Finding Identifiers and Parameters](../../platform-deep-dive/integrations/finding-identifiers-and-parameters) guide for detailed instructions on where to locate these values in FlowX Designer.
</Info>

<Warning>
  The combination of `workspaceId`, `appId`, and `resourceDefinitionId` must be valid and associated in the system. The `processInstanceId` must reference an existing process instance from which values will be inherited.
</Warning>

<ParamField path="workspaceId" type="string" required>
  The ID of the workspace where the process will be started. This parameter is now required to support multi-workspace environments.
</ParamField>

<ParamField path="appId" type="string" example="dbe0ab87-539b-4015-962d-6e73226b9e58" required>
  The ID of the application in which the process will be started.
</ParamField>

<ParamField path="resourceDefinitionId" type="string" required>
  The ID of the resource definition that defines the process to be started. This is typically used when starting processes from event handlers.
</ParamField>

<ParamField path="processInstanceId" type="string" required>
  The UUID of the related process instance from which parameter values will be inherited. This allows the new process to start with data from an existing process.
</ParamField>

## Request Headers

<ParamField header="Authorization" type="string" required={true}>
  Bearer token required for authentication. Format: `Bearer <token>`.
</ParamField>

<ParamField header="Content-Type" type="string" required={true}>
  Indicates the media type of the request body. Must be set to `application/json`.
</ParamField>

<ParamField header="Flowx-Platform" type="string" required={true}>
  Identifies the client platform (e.g., `web`, `mobile`).
</ParamField>

<ParamField header="Accept" type="string" required={false}>
  Specifies the media types that are acceptable for the response. Example: `application/json, text/plain, */*`.
</ParamField>

<ParamField header="Accept-Encoding" type="string" required={false}>
  Indicates supported content encoding algorithms for the response. Example: `gzip, deflate, br, zstd`.
</ParamField>

<ParamField header="Accept-Language" type="string" required={false}>
  Specifies language preferences for the response. Example: `en-GB,en-US;q=0.9,en;q=0.8`.
</ParamField>

## Request Body

The request body should contain a `paramsToInherit` object that controls which parameter values are inherited from the related process instance.

<ParamField body="paramsToInherit" type="object" required>
  A map containing information about which values to copy from the related process instance. This object can contain one of the following keys:

  * **`paramsToCopy`** (array of strings): Use this to pick only a subset of parameters to be inherited from the parent process. It holds the list of key names that will be inherited from the parent parameters.
  * **`withoutParams`** (array of strings): Use this to remove specific parameter values from the parent process before inheriting them. It holds the list of key names that will be removed from the parent parameters.

  If neither key is provided or both are empty, all parameter values from the parent process will be inherited by the new process.
</ParamField>

### Example Request Body

<CodeGroup>
  ```json Inherit specific parameters theme={"system"}
  {
    "paramsToInherit": {
      "paramsToCopy": ["customerName", "customerId", "accountType"]
    }
  }
  ```

  ```json Exclude specific parameters theme={"system"}
  {
    "paramsToInherit": {
      "withoutParams": ["temporaryToken", "sessionData"]
    }
  }
  ```

  ```json Inherit all parameters theme={"system"}
  {
    "paramsToInherit": {}
  }
  ```
</CodeGroup>

<Tip>
  When designing your process inheritance strategy, consider which parameters are truly needed in the new process. Use `paramsToCopy` for explicit control or `withoutParams` to exclude sensitive or temporary data.
</Tip>

## Response

<ResponseField name="processDefinitionFlowxUuid" type="string" example="66e74ea1-0775-42b4-b27e-a4a21ea78dfc">
  The unique identifier of the process definition within FlowX.
</ResponseField>

<ResponseField name="buildId" type="string" example="7d5560be-3846-49fa-9c17-4059c54c7c5f">
  The ID of the build associated with the process.
</ResponseField>

<ResponseField name="buildStatusAtStart" type="string" example="COMMITTED">
  The status of the build at the time the process was started (e.g., "COMMITTED").
</ResponseField>

<ResponseField name="applicationId" type="string" example="dbe0ab87-539b-4015-962d-6e73226b9e58">
  The ID of the application where the process was initiated.
</ResponseField>

<ResponseField name="workspaceId" type="string">
  The ID of the workspace where the process was started.
</ResponseField>

<ResponseField name="parentApplicationId" type="string or null" example="null">
  The ID of the parent application if applicable, otherwise `null`.
</ResponseField>

<ResponseField name="rootApplicationId" type="string or null" example="null">
  The ID of the root application if applicable, otherwise `null`.
</ResponseField>

<ResponseField name="processDefinitionName" type="string" example="customer_onboarding_child">
  The name of the process definition that was started.
</ResponseField>

<ResponseField name="tokens" type="array" example="[{&#x22;id&#x22;: 2112691, &#x22;state&#x22;: &#x22;ACTIVE&#x22;, &#x22;statusCurrentNode&#x22;: &#x22;ARRIVED&#x22;}]">
  A list of tokens representing active workflow states within the process.
</ResponseField>

<ResponseField name="state" type="string" example="STARTED">
  The current state of the process instance (e.g., "STARTED").
</ResponseField>

<ResponseField name="uuid" type="string" example="24cb4216-83a4-4782-84cb-d702b54b9b7d">
  The unique identifier for the newly created process instance.
</ResponseField>

<ResponseField name="instanceMetadata" type="object" example="{&#x22;processInstanceId&#x22;: 2112617, &#x22;processInstanceUuid&#x22;: &#x22;24cb4216-83a4-4782-84cb-d702b54b9b7d&#x22;}">
  Metadata related to the process instance, including:

  * `processInstanceId`: The numeric ID of the process instance.
  * `processInstanceUuid`: The UUID of the process instance.
</ResponseField>

### Response Headers

<ResponseField name="Access-Control-Allow-Credentials" type="boolean" example="true">
  Indicates whether the response can be exposed when credentials are present. Value is `true`.
</ResponseField>

<ResponseField name="Access-Control-Allow-Headers" type="string" example="DNT,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization,flowx-platform">
  Lists the allowed headers in the actual request.
</ResponseField>

<ResponseField name="Access-Control-Allow-Methods" type="string" example="GET, PUT, POST, DELETE, PATCH">
  Specifies the allowed HTTP methods.
</ResponseField>

<ResponseField name="Access-Control-Allow-Origin" type="string">
  Indicates the allowed origin for cross-origin requests.
</ResponseField>

<ResponseField name="Content-Encoding" type="string" example="gzip">
  Specifies the encoding used to compress the response.
</ResponseField>

<ResponseField name="Content-Type" type="string" example="application/json">
  Indicates the media type of the response content.
</ResponseField>

<ResponseField name="Strict-Transport-Security" type="string" example="max-age=31536000 ; includeSubDomains">
  Enforces secure (HTTPS) connections to the server.
</ResponseField>

<ResponseField name="X-Content-Type-Options" type="string" example="nosniff">
  Prevents the browser from MIME-sniffing a response away from the declared `Content-Type`.
</ResponseField>

<ResponseField name="X-XSS-Protection" type="string" example="0">
  Controls the cross-site scripting (XSS) filter.
</ResponseField>

<RequestExample>
  ```bash cURL - Inherit specific parameters theme={"system"}
  curl -X POST "{BASE_URL}/api/runtime/wks/{workspaceId}/app/{appId}/rdi/{resourceDefinitionId}/start/inherit-from/{processInstanceId}" \
    -H "Authorization: Bearer <token>" \
    -H "Content-Type: application/json" \
    -H "flowx-platform: web" \
    -H "Accept: application/json" \
    -d '{
      "paramsToInherit": {
        "paramsToCopy": ["customerName", "customerId", "accountType"]
      }
    }'
  ```

  ```bash cURL - Exclude specific parameters theme={"system"}
  curl -X POST "{BASE_URL}/api/runtime/wks/{workspaceId}/app/{appId}/rdi/{resourceDefinitionId}/start/inherit-from/{processInstanceId}" \
    -H "Authorization: Bearer <token>" \
    -H "Content-Type: application/json" \
    -H "flowx-platform: web" \
    -H "Accept: application/json" \
    -d '{
      "paramsToInherit": {
        "withoutParams": ["temporaryToken", "sessionData"]
      }
    }'
  ```

  ```bash cURL - Inherit all parameters theme={"system"}
  curl -X POST "{BASE_URL}/api/runtime/wks/{workspaceId}/app/{appId}/rdi/{resourceDefinitionId}/start/inherit-from/{processInstanceId}" \
    -H "Authorization: Bearer <token>" \
    -H "Content-Type: application/json" \
    -H "flowx-platform: web" \
    -H "Accept: application/json" \
    -d '{
      "paramsToInherit": {}
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json Success Response theme={"system"}
  {
    "processDefinitionFlowxUuid": "66e74ea1-0775-42b4-b27e-a4a21ea78dfc",
    "buildId": "7d5560be-3846-49fa-9c17-4059c54c7c5f",
    "buildStatusAtStart": "COMMITTED",
    "applicationId": "dbe0ab87-539b-4015-962d-6e73226b9e58",
    "workspaceId": "ws-123456789",
    "parentApplicationId": null,
    "rootApplicationId": null,
    "processDefinitionName": "customer_onboarding_child",
    "tokens": [
      {
        "id": 2112691,
        "state": "ACTIVE",
        "statusCurrentNode": "ARRIVED"
      }
    ],
    "state": "STARTED",
    "uuid": "24cb4216-83a4-4782-84cb-d702b54b9b7d",
    "instanceMetadata": {
      "processInstanceId": 2112617,
      "processInstanceUuid": "24cb4216-83a4-4782-84cb-d702b54b9b7d"
    }
  }
  ```
</ResponseExample>

## Triggering from FlowX Designer

This endpoint is triggered through a **Send data to user interface** node action configured in FlowX Designer:

<Steps>
  <Step title="Add node action">
    Add a **Send data to user interface** action to the node where you want to trigger the child process.
  </Step>

  <Step title="Configure message type">
    Set the **Message type** to `action` to enable process triggering capabilities.
  </Step>

  <Step title="Configure inheritance parameters">
    In the action configuration, specify which parameters should be inherited using `paramsToCopy` or `withoutParams` in the action payload.
  </Step>
</Steps>

<Info>
  For detailed instructions on configuring node actions in FlowX Designer, see the [Managing a Process Flow](../../flowx-designer/managing-a-project-flow/starting-a-process) documentation.
</Info>

## Use Cases

This endpoint is particularly useful for:

* **Multi-step workflows**: Starting a child process that continues work begun in a parent process
* **Process chaining**: Creating related processes that share common data
* **UI-triggered actions**: Starting processes from user interface actions that need to carry over existing data
* **Data inheritance**: Maintaining context across related process instances while controlling which data is passed forward

<Note>
  This endpoint is specifically designed for runtime operations initiated from event handlers. The `workspaceId` parameter ensures proper isolation in multi-tenant environments.
</Note>