Extend List Properties

Audience: Low-code Engineers

Skill Prerequisites: Actions, Lists, Tokens

Adds properties to the entries of a list, or changes the value of existing ones. It works in two ways:

• Outside a loop, it sets the properties on every entry of the list, with the same values.
• Inside Execute Actions for each List Entry, it sets them on the current entry only, so each entry can get its own value.

A property can also point to another list or to an object, to describe nested data for Create JSON Object.

Typical Use Cases

• Add a calculated property to each entry, for example a full name or a status, inside a loop
• Add the same value to every entry, for example an import batch ID, before Import List into Database
• Change a value on an entry after processing it, for example set Processed to true
• Nest a list of lines inside each order entry before building JSON

Don't use it to

• Add a new entry. Use Add List Entry instead.
• Rename or reshape properties. Use Remap List instead.
• Change a property of an object. Use Extend Object Properties instead.

Related Actions

Action Name	Description
Execute Actions for each List Entry	Runs actions for each entry. Put this action inside it to set a different value per entry.
Add List Entry	Adds a new entry to a list.
Remap List	Renames or reshapes list properties.
Create Object	Creates an object that a property can point to.
Create JSON Object	Turns lists into JSON, expanding the list and object properties.

Input Parameter Reference

Parameter	Description	Supports Tokens	Default	Required
List Name	The name of the list to change, for example ContactsList. List names are case-sensitive. Outside a loop, if the list doesn't exist, nothing happens.	Yes	empty string	Yes
Properties	Plain properties to add or change. Each row has a Property Name, for example FullName, and a Property Value, for example [ContactsList:FirstName] [ContactsList:LastName].	Yes	empty	No
List Object Properties	Properties that point to an object. Each row has a Property Name, for example Address, and a Referenced Object, which is the name of an object from Create Object.	Yes	empty	No
List Properties	Properties that point to a list. Each row has a Property Name, for example Lines, and a Referenced List, which is the name of another list.	Yes	empty	No

In all three, both columns support tokens. Values are resolved when the action runs and are saved as text.

Inside and outside a loop

Where the action runs	What changes
Directly in the actions of Execute Actions for each List Entry, or inside an Execute Actions there	The current entry of the loop. Tokens such as [ContactsList:FirstName] hold that entry's values, so each entry can get a different value.
Anywhere else	Every entry of the list. Tokens are resolved once for the whole list, so every entry gets the same value.

Inside a loop, the action always changes the loop's current entry, even if List Name is a different list. Set List Name to the list you're looping over.

Repeat doesn't keep the current entry. Inside a Repeat that's inside a loop, the action changes every entry of the list.

Considerations

• New properties aren't tokens yet. The entry tokens of the loop are created at the start of each iteration. A property added in the loop isn't available as [ListName:Property] in the same iteration. Keep the value in a token if you need it right away.
• Changes are kept. Changes to entries stay after the loop, whatever the loop's Context Behavior.
• Set every entry. Inside a loop with a condition, entries that are skipped don't get the property. Some actions then show empty values, and Create JSON Object can fail. Give the property a default value on the whole list first, by running this action outside the loop.
• Existing properties. A property with the same name is overwritten.
• List and object references. Only the name of the referenced list or object is saved. It's looked up when Create JSON Object runs, so it must exist by then. Nothing stops a list from pointing to itself. Create JSON Object fails with an "infinite loop" error when it finds this.
• Listing rows. The rows of a listing are read again each time they're used, so properties added to them aren't kept.

Examples

tip

To understand how to use the below examples, please see Running Examples.

1. Add a batch ID to every entry

This action adds an ImportBatchId property with the same value to every entry of ContactsList. It runs outside a loop, for example just before Import List into Database.

{
    "Title": "Extend List Properties",
    "ActionType": "ExtendEntity",
    "Description": "Tag the contacts with the batch ID",
    "Parameters": {
        "EntityName": "ContactsList",
        "EntityProps": [
            {
                "name": "ImportBatchId",
                "value": "[BatchId]"
            }
        ],
        "EntityObjProperties": [],
        "EntityListProperties": []
    }
}

2. Add a full name to each entry

This action loops over ContactsList and gives each entry a FullName property built from its own first and last name.

{
    "Title": "Execute Actions for each List Entry",
    "ActionType": "ExecuteActionsOnEntityList",
    "Description": "Build each contact's full name",
    "Parameters": {
        "EntityName": "ContactsList",
        "Filters": [],
        "ContextBehavior": {
            "Expression": "",
            "Value": "NoPreserve",
            "IsExpression": false,
            "Parameters": {}
        },
        "ActionList": [
            {
                "Title": "Extend List Properties",
                "ActionType": "ExtendEntity",
                "Description": "Set the full name",
                "Parameters": {
                    "EntityName": "ContactsList",
                    "EntityProps": [
                        {
                            "name": "FullName",
                            "value": "[ContactsList:FirstName] [ContactsList:LastName]"
                        }
                    ],
                    "EntityObjProperties": [],
                    "EntityListProperties": []
                }
            }
        ],
        "ContinueOnError": false,
        "OnError": []
    }
}

3. Nest each order's lines

For each order in OrdersList, this loop builds a list of its lines with Create List from SQL, named after the order, for example Lines1001List. It then adds a lines property that points to that list. Create JSON Object with the List type on OrdersList then writes each order with its lines as a nested array.

{
    "Title": "Execute Actions for each List Entry",
    "ActionType": "ExecuteActionsOnEntityList",
    "Description": "Attach the lines to each order",
    "Parameters": {
        "EntityName": "OrdersList",
        "Filters": [],
        "ContextBehavior": {
            "Expression": "",
            "Value": "NoPreserve",
            "IsExpression": false,
            "Parameters": {}
        },
        "ActionList": [
            {
                "Title": "Create List from SQL",
                "ActionType": "LoadEntitiesFromSql",
                "Description": "Load the order's lines",
                "Parameters": {
                    "SqlQuery": "SELECT Sku, CAST(Quantity AS nvarchar(20)) AS Quantity FROM OrderLines WHERE OrderId = @OrderId",
                    "BindTokens": [
                        {
                            "name": "OrderId",
                            "value": "[OrdersList:OrderId]"
                        }
                    ],
                    "EntityName": "Lines[OrdersList:OrderId]List"
                }
            },
            {
                "Title": "Extend List Properties",
                "ActionType": "ExtendEntity",
                "Description": "Point to the lines",
                "Parameters": {
                    "EntityName": "OrdersList",
                    "EntityProps": [],
                    "EntityObjProperties": [],
                    "EntityListProperties": [
                        {
                            "name": "lines",
                            "value": "Lines[OrdersList:OrderId]List"
                        }
                    ]
                }
            }
        ],
        "ContinueOnError": false,
        "OnError": []
    }
}

Each order needs its own lines list, because the reference is only a name. If every order pointed to the same list name, they'd all show the last order's lines.

Revised 09/27/2026