Remap List

Audience: Low-code Engineers

Skill Prerequisites: Actions, Lists, Tokens

Creates a list with renamed properties from another list. A second list, the mapping list, says which source property becomes which new property. Each item of the result has only the mapped properties, plus any additional properties you add.

For example, a mapping list with the entries first_name → FirstName and email_address → Email turns items with first_name, last_name and email_address into items with only FirstName and Email.

Typical Use Cases

• Rename the properties of a list from an external API to the names your application uses
• Keep only some properties of a list before exporting it with Create CSV from List or List to JSON
• Match a list's property names to the columns of a table before Import List into Database
• Keep the mapping in a database table, so it can change without editing the actions

Don't use it to

• Add properties to a list and keep all the existing ones. Use Extend List Properties instead.
• Change the columns of data you read from a database. Use column aliases in the query of Create List from SQL instead.

Related Actions

Action Name	Description
Create List from JSON	Creates the source list or the mapping list from JSON.
Create List from SQL	Creates the source list or the mapping list from a query.
Extend List Properties	Adds or changes properties and keeps the others.
Import List into Database	Saves the remapped list to a table.
Execute Actions for each List Entry	Runs actions once for each item of the result.

Input Parameter Reference

Parameter	Description	Supports Tokens	Default	Required
Source List	The name of the list to remap, for example ApiContactsList. The name is case-sensitive.	Yes	empty string	Yes
Mapping List	The name of the mapping list, for example FieldMapList. Each of its items maps one source property to one new property.	Yes	empty string	Yes
Mapping List - Source Property	The property of the mapping list that holds the source property names, for example From.	Yes	empty string	Yes
Mapping List - Target Property	The property of the mapping list that holds the new property names, for example To.	Yes	empty string	Yes
Additional Properties	Extra properties to add to every item. Each row has a Property Name, for example Source, and a Value, for example API or [first_name] [last_name]. See Additional properties.	Yes (values)	empty	No
Result List Name	The name of the new list, for example ContactsList. If a list with this name exists, it's replaced. Use the same name as Source List to replace the source list.	Yes	empty string	Yes

Output Parameters Reference

Output	Description
List <Result List Name>	One item per source item, in the same order, with the mapped and additional properties.
[<Result List Name>:Count]	The number of items. If the source list has a [<Source List>:Count] token, its value is copied. When the result replaces the source list, [<Source List>:Count] is left as it is.

How the mapping works

For each source item, the action goes through the mapping list:

• It reads the source name from Mapping List - Source Property and the new name from Mapping List - Target Property.
• If the source item has a property with the source name, the new item gets a property with the new name and the same value. Property names aren't case-sensitive.
• If the source item doesn't have it, the new property is left out for that item.

Source properties that aren't in the mapping list are dropped. Values keep their type, so a number stays a number.

You can map one source property to several new names, one mapping entry each.

Additional properties

Additional property values are text. Tokens in them are replaced for each item. While an item is processed, each of its source properties is available as a token by its source name, for example [first_name], not [ApiContactsList:first_name]. Other tokens from the context work too.

Additional properties are only added when the mapping list has at least one item.

Considerations

• Missing lists or properties. The action fails if the source list or the mapping list doesn't exist, or if the mapping list doesn't have the two mapping properties. Use the On Error actions of Execute Actions to handle the error.
• Required parameters. All parameters except Additional Properties are required. The action fails if one is empty.
• The result follows the source. The result isn't a copy. It reads the source list each time it's used, for example by each Execute Actions for each List Entry. Additional property tokens are also replaced each time.
• Tokens left behind. Reading the result sets tokens named after the source properties, for example [first_name], in the context where Remap List ran. After the list is read, they hold the last item's values and replace tokens with the same names. Use source property names that don't clash with your tokens.
• Nested JSON. The result doesn't keep the JSON text of nested objects and arrays that Create List from JSON makes available in loops. To keep a nested value, map its path, for example address.city.

Examples

tip

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

1. Rename the properties of an API response

First, create the mapping list with Create List from JSON. Each item has a From and a To property.

{
    "Title": "Create List from JSON",
    "ActionType": "LoadEntitiesFromJson",
    "Description": "Create the property mapping",
    "Parameters": {
        "JsonModel": "[{\"From\": \"first_name\", \"To\": \"FirstName\"}, {\"From\": \"last_name\", \"To\": \"LastName\"}, {\"From\": \"email_address\", \"To\": \"Email\"}]",
        "EntityName": "FieldMapList"
    }
}

Then, this action remaps ApiContactsList into ContactsList. Each item has FirstName, LastName and Email, plus FullName, built from the source properties, and Source, which is always API.

{
    "Title": "Remap List",
    "ActionType": "RemapEntityList",
    "Description": "Rename the API contact properties",
    "Parameters": {
        "SourceEntityName": "ApiContactsList",
        "MappingEntityName": "FieldMapList",
        "MappingEntitySourcePropertyName": "From",
        "MappingEntityTargetPropertyName": "To",
        "AdditionalProperties": [
            {
                "name": "FullName",
                "value": "[first_name] [last_name]"
            },
            {
                "name": "Source",
                "value": "API"
            }
        ],
        "ResultEntityName": "ContactsList"
    }
}

2. Use a mapping stored in a table

If the mapping is stored in a table, load it with Create List from SQL, for example with SELECT ExternalName, InternalName FROM ImportMapping, into ImportMapList. This action then remaps ImportList in place.

{
    "Title": "Remap List",
    "ActionType": "RemapEntityList",
    "Description": "Apply the import mapping",
    "Parameters": {
        "SourceEntityName": "ImportList",
        "MappingEntityName": "ImportMapList",
        "MappingEntitySourcePropertyName": "ExternalName",
        "MappingEntityTargetPropertyName": "InternalName",
        "AdditionalProperties": [],
        "ResultEntityName": "ImportList"
    }
}

Revised 09/27/2026