Skip to main content

Intro to data types

Learn the data types in Actioner.


In this document, we will cover simple and complex data types (strings, numbers, booleans, lists/arrays, objects, null) you come across in Actioner workflows.

All data can be divided into various types, and the specific type of the data determines its behavior and what you can do with it. Each data type can contain different kinds of values from each other and has its own rules for how to interact with it. While designing a workflow, you are creating the framework of how Actioner interacts with the flowing data, how to handle the incoming data and process it and how to format it and where to send it next.

It is crucial to understand the different data types and how they behace while designing a workflow.

Data types


Let's begin by looking at string data type, which are used in text fields in Actioner. Strings are typically used for text and are represented by enclosing the text within quotation marks.

"This is a string wrapped in quotation marks"

A string can also contain numbers or symbols, like in an email address or a phone number.

"+1 (555) 123-4567"


Up next, we have numbers. There are actually two data types for numerical values and they have a slight difference between them. The first one is called an "integer" and can only be a whole number. It can be positive or negative, but it has to be a whole number. The other data type is a "floating point value" (or "float" for short) and this is the data type of any numbers with a decimal point.



Booleans are very simple, but also very useful!

A boolean is a binary data type, meaning it can only have one of two possible values; true or false (sometimes represented as 1 and 0). You would commonly see a boolean as the backend value (meaning what the value looks like “behind the scenes”) for a checkbox field for example.


It’s important to note that a boolean value is not a string, and therefore not wrapped in quotes.


Unlike strings, numbers and booleans which are all very simple data types that contain a single value, lists or arrays are a little complex.

Lists can contain any number of values and act as a container for data items. An array is represented by a set of square brackets (such as [ ]) and all the values within the array will be listed inside the brackets, separated by commas.

[ "apple", "kiwi", "bread", "milk" ]
[ 1, 2, 3 ]


Objects are also a complex data type, similar to arrays. The main difference is that the array contains values that are independent from each other, while an object contains values that describe different aspects of a single entity.

An object is represented by a set of curly brackets { }. The values within an object are called properties and each property is written out as a key:value pair within the curly brackets.

{ "property_name": "property_value" }

Much like an array, the values of an object can be of different types.

"name": "John Doe",
"age": 27,
"job": "Developer"

Keys can only be string.

It is also possible to have nested objects, where the value of a property is an object with its own properties.

"name": "John Doe",
"age": 27,
"job": "Developer",
"address": {
"street": "123 Actioner Avenue",
"city": "Actionerville",
"zipcode": "123ABC",
"country": "Actionerland"

The properties within an object are identified by the keys of the key:value pairs, i.e. the "property name".


Compared to the previous data types we have looked at, null is quite different. The simplest way to describe is that null represents the absence of a value.

Let’s take another look at our example from the "Object" data type. At present, John Doe is 27 years old and working as a developer.

"name": "John Doe",
"age": 27,
"job": "Developer"

If we were to look back to three years ago however, John was 24 years old and at college. To replicate what this object might have looked like back then, we could of course just remove the entire "job" property and not have to worry about it. But if that property is required for some reason and we have to add something to it, we could use null to represent the intentional absence of a value.

"name": "John Doe",
"age": 24,
"job": null