Gain Insights in Adoption Rate & License Consumption

As organizations scale their use of Experlogix Smart Flows, understanding how the platform is being used becomes just as important as what it can do. Questions like which flows are actively used, which templates drive the most value, and how license capacity is consumed over time are essential for making informed operational, financial, and product decisions.

Without clear visibility, teams risk underutilizing licensed capabilities, overlooking adoption bottlenecks, or scaling automation without knowing where capacity constraints may arise.

This tutorial focuses on how to gain actionable insights into adoption rates and license consumption using the reporting capabilities in Experlogix Smart Flows. These reports provide transparency across stages, users, flows and templates, enabling administrators and decision-makers to:

• Monitor how actively Smart Flows is used across teams and processes

• Identify high-value and underutilized flows or templates

• Track license usage and consumption trends

• Support capacity planning and informed licensing decisions

By combining operational usage data with licensing insights, Smart Flows reporting helps organizations move from automation in use to automation under control, ensuring that investments in document and process automation continue to deliver measurable value as adoption grows.

Check the License and Release DatesLicense and Release Dates table below to verify if your Experlogix Smart Flows version and license supports all features mentioned in this tutorial.

License and Release Dates

How to use the Smart Flows Reporting API endpoints

Experlogix Smart Flows exposes reporting API endpoints that allow you to access usage, adoption, and license consumption data programmatically. This API-first approach enables organizations to go beyond out-of-the-box dashboards and integrate Smart Flows reporting data directly into their own analytics and monitoring ecosystems.

Report Types

The reporting APIs in Experlogix Smart Flows are organized around various Types. A report type defines what kind of insight you want to extract from the system and determines which data points (output columns) are available in the response.

By selecting the appropriate type, you can focus your reporting on user activity, flow adoption, template usage, or license consumption, without having to filter irrelevant data afterward.

Below is an overview of the available report types, what they are typically used for, and the output columns they support.

Reporting Types overview

Reporting Views

For each of the report types, Smart Flows comes with one or more Reporting Views. A view is a filtered result set of reporting records of one of the report types. It is defined by:

• a filter definition

• a set of columns to include in the output

• an ordering of the included columns

Advanced reporting options

By targeting the Reporting View endpoints, you can retrieve relevant reporting data. Advanced reporting view options help you distill actionable insights from that data:

• Aggregate results - Perform calculations on the retrieved results, to track insights in the form of key numbers

• Define query parameters - Set parameters to page, sort and format reporting data

Aggregating reporting view data

Aggregations allow you to group and summarize data returned by Experlogix Smart Flows reporting views. Instead of retrieving individual reporting lines, aggregation enables you to answer higher-level questions such as:

• How many executions occurred per flow?

• What is the total or average DPU consumption user, per flow or per template?

• Which flows or templates are used most frequently?

Aggregations are defined by grouping one or more columns and applying aggregation functions to selected fields.

Aggregation structure

An aggregation request consists of two main parts:

• groupByColumns - defines how the data should be grouped

• aggregationColumns - defines which values should be aggregated

{
  "groupByColumns": ["column1", "column2"],
  "aggregationColumns": [
    {
      "columnName": "columnName",
      "distinctValues": false,
      "function": "aggregationFunction"
    }
  ]
 

groupByColumns is a list of column names used to group the result set. At least one column must be specified.

• Column names must match the column names exposed by the reporting view.

• Each unique combination of grouped columns results in one aggregated record.

Example use cases:

• Group executions by flow.id

• Group logins by user.id

• Group DPU consumption by date

aggregationColumns defines which columns should be aggregated and which aggregation function should be applied.

• At least one aggregation column must be defined

• Each aggregation column specifies:

  • Tthe source column

  • Tthe aggregation function

  • Wwhether distinct values should be considered

distinctValues

• Defaults to false

• When set to true, only unique values are considered during aggregation

• Functions that do not support distinct values (min, max, concat) silently ignore this setting

Example aggregation

The following example groups execution data by flow and counts how many executions occurred per flow.

{
  "groupByColumns": [
    "flow.id",
    "flow.name"
  ],
  "aggregationColumns": [
    {
      "columnName": "execution_count",
      "viewColumnName": "flow.id",
      "aggregationType": "COUNT"
    }
  ]
}
 

This query groups data by flow.id and flow.name and counts the number of execution records per flow.

{
  "data": [
    {
      "execution_count": 7,
      "flow": {
        "id": "7DFDC541-40FF-4C41-B86B-0C731EBF5DD9",
        "name": "Show account info"
      }
    },
    {
      "execution_count": 3,
      "flow": {
        "id": "9E4B744D-0CF2-48C2-A326-11D4AF9A7005",
        "name": "Create quote"
      }
    }
  ]
 

Supported aggregation functions

The following endpoints are available for executing aggregation queries:

• POST /api/v1/reporting/views/{view}/aggregate

  Returns aggregated results as JSON

• POST /api/v1/reporting/views/{view}/aggregate/download

  Returns aggregated results as a downloadable file

Defining query parameters: paging, sorting, and output options

When retrieving data from Smart Flows reporting views, all requests support pagination, sorting, filtering, and output customization. These query parameters allow you to efficiently navigate large result sets and shape the response to fit downstream reporting or integration needs.

Paging and sorting - Paging parameters

Sorting parameters

Paging and sorting examples

GET /reporting/views/login/data?page=0&size=25

GET /reporting/views/login/data?page=1&size=10&sort=timestamp,desc

GET /reporting/views/execution/data?page=0&size=20&sort=timestamp,desc&sort=flow.name,asc

Output formatting

Following query parameters define how the reporting data is formatted.

Time zone handling - Time zone parameters

Time range and phase filtering - Filter parameters

CSV export options

CSV-specific parameters apply only when the selected output format supports CSV export.

Usage examples

GET /reporting/views/login/data

GET /reporting/views/execution/data?flat=true&normalizeNames=true

GET /reporting/views/execution/data?timeRangeType=last24Hours&phase=production

GET /reporting/views/login/data?timeRangeType=custom&timeRangeStart=2023-01-01T00:00:00Z&timeRangeEnd=2023-01-31T23:59:59Z

GET /reporting/views/dpu/data?format=csv&csvDelimiter=;&csvLineEnding=crlf&csvNullValue=N/A

GET /reporting/views/template/data?timeZone=Europe/Brussels

Beyond views - retrieving and formatting custom reporting data

Defining filters for reporting data retrieval

The reporting API supports powerful, structured filtering that allows you to precisely control which records are returned. Filters are defined as a tree of nodes, where each node is either:

• Aa single condition, or

• aA group of conditions combined with logical operators (AND, OR)

A node must contain either a condition or a group — never both.

Filter structure overview - Basic filter node types

{
  "condition": {
    "key": "user.tags",
    "operator": "contains",
    "values": ["salesteam"]
  }
}
 

{
  "group": {
    "operator": "AND",
    "nodes": [
      {
        "condition": {
          "key": "flow.id",
          "operator": "equalTo",
          "values": ["c47410a7-da52-49ef-8f4f-940b3d339af3"]
        }
      },
      {
        "condition": {
          "key": "phase",
          "operator": "equalTo",
          "values": ["test"]
        }
      }
    ]
  }
}
 

{
  "group": {
    "operator": "AND",
    "nodes": [
      {
        "condition": {
          "key": "executedby.tags",
          "operator": "contains",
          "values": ["salesteam"]
        }
      },
      {
        "condition": {
          "key": "dpuconsumed",
          "operator": "greaterThan",
          "values": ["1"]
        }
      }
    ]
  }
}
 

{
  "group": {
    "operator": "OR",
    "nodes": [
      {
        "condition": {
          "key": "flow.trigger",
          "operator": "equalTo",
          "values": ["salesforce"]
        }
      },
      {
        "condition": {
          "key": "flow.trigger",
          "operator": "equalTo",
          "values": ["dynamics"]
        }
      }
    ]
  }
}
 

{
  "group": {
    "operator": "OR",
    "nodes": [
      {
        "group": {
          "operator": "AND",
          "nodes": [
            {
              "condition": {
                "key": "executedby.tags",
                "operator": "contains",
                "values": ["salesteam"]
              }
            },
            {
              "condition": {
                "key": "dpuconsumed",
                "operator": "greaterThan",
                "values": ["1"]
              }
            }
          ]
        }
      },
      {
        "condition": {
          "key": "flow.trigger",
          "operator": "equalTo",
          "values": ["salesforce"]
        }
      }
    ]
  }
}
 

{
  "group": {
    "operator": "OR",
    "nodes": [
      { "condition": { "key": "user.name", "operator": "equalTo", "values": ["alice"] } },
      { "condition": { "key": "user.name", "operator": "equalTo", "values": ["bob"] } },
      { "condition": { "key": "user.name", "operator": "equalTo", "values": ["charlie"] } }
    ]
  }
}
 

{
  "group": {
    "operator": "AND",
    "nodes": [
      {
        "condition": {
          "key": "dpuconsumed",
          "operator": "greaterThanOrEqualTo",
          "values": ["1"]
        }
      },
      {
        "condition": {
          "key": "dpuconsumed",
          "operator": "lessThanOrEqualTo",
          "values": ["3"]
        }
      }
    ]
  }
}
 

Supported condition operators

{
  "key": "dpuconsumed",
  "operator": "between",
  "values": ["1", "3"]
}
 

{
  "key": "template.name",
  "operator": "contains",
  "values": ["Invoice"]
}
 

{
  "key": "executedby.tags",
  "operator": "in",
  "values": ["salesteam", "marketingteam", "presalesteam"]
}
 

Formatting the output of a custom report

Reporting queries can return data in multiple output formats, allowing you to choose the structure that best fits your integration, reporting, or export scenario. Output formatting is controlled through a combination of the format query parameter and standard HTTP headers.

Structured text formats (JSON and XML)

Structured output formats can be returned as JSON or XML, depending on the Accept header of the request:

• If the Accept header specifies a MIME type compatible with JSON, the response is returned as JSON.

• If the Accept header specifies a MIME type compatible with XML, the response is returned as XML.

• If no compatible MIME type is specified, JSON is returned by default.

MIME type compatibility rules

Two MIME types are considered compatible if:

• Their primary types match (or either uses the wildcard *)

• Their subtypes match (or either uses the wildcard *)

Examples:

• application/* is compatible with application/json

• For XML responses, use application/xml or text/xml

To explicitly request XML output, ensure the Accept header contains only an XML-compatible MIME type and does not include any MIME types compatible with JSON.

GET /api/v1/reporting/types/execution/data?format=resultset

{
  "columns": [
    { "name": "timestamp", "type": "DateTime" },
    { "name": "phase", "type": "String" },
    { "name": "execution.id", "type": "Uuid" },
    { "name": "executedby.name", "type": "String" }
  ],
  "rows": [
    {
      "timestamp": "2025-11-17T10:16:26.346807400Z",
      "phase": "TEST",
      "execution.id": "6D5331BE-0B52-4624-9E26-15132BD9B461",
      "executedby.name": "admin"
    }
  ],
  "pageNumber": 0,
  "pageSize": 20,
  "totalRecords": 10
}
 

GET /api/v1/reporting/types/execution/data?format=reportingdata

{
  "data": [
    {
      "timestamp": "2025-11-17T10:16:26.346807400Z",
      "phase": "TEST",
      "execution": { "id": "6D5331BE-0B52-4624-9E26-15132BD9B461" },
      "executedby": {
        "name": "admin",
        "tags": ["Users.Good"]
      },
      "flow": {
        "id": "9E4B744D-0CF2-48C2-A326-11D4AF9A7005",
        "name": "onder dataset"
      }
    }
  ]
}
 

GET /api/v1/reporting/types/execution/data?format=recordlist

[
  {
    "timestamp": "2025-11-17T10:16:26.346807400Z",
    "phase": "TEST",
    "execution": { "id": "6D5331BE-0B52-4624-9E26-15132BD9B461" },
    "executedby": { "name": "admin" },
    "flow": { "id": "9E4B744D-0CF2-48C2-A326-11D4AF9A7005" }
  }
]

GET /api/v1/reporting/types/execution/data?format=csv