ChannelEngine: CE Shell
About this article
This article describes how to use ChannelEngine's scripting language, CE Shell.
Table of contents
Use cases using specific actions
Introduction
CE Shell is ChannelEngine’s scripting language, used to create dynamic values in your product data on ChannelEngine. Currently, CE Shell is available for use in three features:
General use cases
Use CE Shell to create new values based on your current product data, eliminating the need to recreate them from scratch. E.g.: $Feed: Name | ToUpper converts all the values in the Name field of your product feed to uppercase.
Other common use cases of CE Shell include:
- Limiting the number of characters in a value.
- Changing the text case (e.g.: convert to lowercase).
- Adjusting the decimal position (e.g.: truncating to two decimal places).
- Replacing one value with another.
- Merging multiple values into one.
- Performing mathematical operations (e.g.: division, multiplication).
- Finding the minimum or maximum of two or more values.
- Creating a new field out of existing fields.
- Using your entire product feed’s data set, even if ChannelEngine only partially imported it.
How to use CE Shell
When mapping your product feed
- All product feed data, including price and stock, are imported as text values into ChannelEngine.
- All feed values are imported into the backend, even if you see a Partially imported label on the feed after importing.
- To perform mathematical actions on these text values, you must first convert the values to integers (ToInteger) or decimals (ToDecimal). E.g.:
$Feed: StockQuantity | ToInteger | Multiply {2} or $Feed: Price | ToDecimal | Divide {3}.
- Custom fields that you configure with CE Shell must be stored back into ChannelEngine as text values. Always finish the syntax with
ToText, e.g.:$Feed: Size | ToDecimal | Multiply {1.2} | ToText. - You only use the variable
$Feed:within CE Shell for mapping the product feed to ChannelEngine fields and custom fields. - Currently, you can apply CE Shell to CSV and JSON product feed formats. If you need to apply CE Shell to an XML product feed, reach out to the Support team to get this configured.
When creating smart custom fields
- Any custom fields that are enhanced with CE Shell to create smart custom fields are treated as text values and require a conversion process before performing mathematical actions on them. E.g.:
$MY: Width | ToInteger | Multiply {2}, or$MY: Sleeve-length | ToDecimal | Divide {3}. - Meanwhile, default ChannelEngine fields do not require any conversion before performing mathematical actions, and their data types are correctly recognized. E.g.:
$CE: Price | Add {10}.
When building custom fields with AI attribute builder
- Instruct the AI attribute builder with a CE Shell prompt in the What should it extract, combine, or improve? dialog box.
- Automatically generate a CE Shell prompt by clicking Enhance prompt.
CE Shell syntax
CE Shell uses a syntax similar to other scripting languages. The key structure of the syntax is the pipeline, which is comprised of:
Variable - the data source, e.g.:
$Feed:Property - the product field, which can be a ChannelEngine field or a custom field, e.g.:
$Feed: CategoryAction(s) - one or more actions, separated by a pipe ( | ), e.g.:
$Feed: Category | Replace {"Shoes";"Sneakers"}Pipeline - the sequence of actions that modify the property, in the order in which you define the actions.
In the example below, the value Shoes is replaced with Sneakers, and then the entire Category string is converted to uppercase. The result is SNEAKERS > SPORTS > TENNIS.
Dynamic syntax
As you type out a CE Shell expression, ChannelEngine offers you auto-complete options and dynamic context based on IntelliSense technology.
Auto-complete suggestions
ChannelEngine dynamically suggests variables, properties, and actions to use and color-codes each property based on its data type so that you know which actions to invoke on it next. View your auto-complete suggestions when you type the $, :, and | operators, or type Ctrl+space.
Fields and actions panel
The panel to the right of the editor lists the fields available to you (ChannelEngine fields, custom fields, and product feed fields), along with the CE Shell actions you can apply. Each entry is labeled with its data type.
- Click a field or an action to insert it at the cursor position, or drag and drop it into the editor.
- Hover over an action to see what it does and which arguments it takes.
The action list updates as you build your expression, showing only the actions that are valid for the current data type. With a text field, like Name, you see text actions like ToUpper and Trim. With a decimal field, like Price, you see Multiply, Round, and other mathematical actions.
Each list in the panel has a search box. Search matches any part of a name, so typing to under Actions returns ToUpper, ToDecimal, and TryToInteger. Clear the search bar to restore the full list.
In-app documentation
As you invoke an action in your expression or hover over any property or action, in-app documentation guides you even further, eliminating the need to search through CE Shell's documentation in another window.
Contextual menu
Right-click an element in your CE Shell expression, and a full contextual menu appears.
When you need to modify an element that appears multiple times in your expression, select Change all occurrences. Or browse the full list of syntax commands in the Command palette.
Real-time error messages
While using CE Shell, ChannelEngine dynamically analyzes the output and displays a real-time error message in the editor. A given element is underlined in red until the syntax matches the known data properties and types in ChannelEngine’s database.
E.g.: when multiplying a text value by an integer, an error message appears at the bottom of the editor until you transform the text to an integer. In this way, you always know if you are following the correct CE Shell syntax.
Defining the data source
The first part of the CE Shell syntax defines a data source for the actions that follow. That data source is a variable and is declared with a dollar sign ( $ ). The source can be:
Your product feed, e.g.:
$FeedCustom fields created on ChannelEngine, e.g.:
$MYStandard ChannelEngine fields, e.g.:
$CE
Referencing fields
To reference a field, follow the data source with a colon (':'), and name the field. The field is your property. Whether you use CE Shell in the advanced rules for product feeds or in smart custom fields, the syntax will change, e.g.: $Feed: Price for fields in product feeds or $MY: SleeveLength for referencing a custom field in smart custom fields.
Data sources and properties used together
| Data source | Syntax & example | Where used | Useful notes |
Product feed |
$Feed: <FieldName> |
Product feed mapping |
The field name must exactly match the case and spelling from your feed. |
Custom fields |
$MY: <FieldName>
|
Smart custom fields |
Your custom fields are fields that you create and that fall outside of the standard ChannelEngine fields. To learn more about custom fields, check out the article ChannelEngine: custom fields. |
ChannelEngine fields |
$CE: <FieldName>
|
Smart custom fields |
ChannelEngine fields have distinct names. You can find the names listed in the article ChannelEngine: replacement tags for channel mappings. |
Fixed values
You can apply an action directly to a fixed value, without defining either a variable or property. E.g.: Sneakers | ToUpper will result in SNEAKERS wherever the fixed value Sneakers appears in your product data. This syntax is useful when using CE Shell actions that do not expect an argument.
Data types
Currently, CE Shell supports the following data types: decimal, integer, text, and boolean, or a collection of these.
Decimal - a number that can have digits after a decimal point. E.g.: 9.14.
Integer - a whole number without a decimal point. E.g.: 9.
Text - a sequence of characters, such as letters, numbers, and symbols, treated as words or phrases. E.g.: This is a Nitro smartphone.
Boolean - a value that is either ‘true’ or ‘false’.
Different actions are reserved for different data types.
With text, you can use text-related actions, such as
ToUpper,ToLower,Trim, orReplace.With decimals and integers, you can invoke mathematical actions, such as
Multiply,Divide,Subtract, orAdd.
Collections of data types
A collection is a group of related values that are stored together. On ChannelEngine, input values cannot arrive as collections. However, you can use CE Shell to create a collection from a series of text values. Once you create a collection, CE Shell can perform actions on elements within the collection.
In your product feed file, your lists must be concatenated and delimited by an operator, such as a comma (,). To perform actions on a concatenated list using CE Shell, use the
Split {}action, and provide your delimiter in the argument. (Check out the section below on Actions.)CE Shell does not perform bulk actions on collections. Instead, perform actions element-by-element. With lists of values, you can use CE Shell to extract a specific element with
ElementAtorTryElementAt. The first element in a list is zero (0). For example, one of your products' fields is an image set. You want to select the third image in the image set, e.g.:$Feed: Image | Split {","} | ElementAt{2}.Or find an element that fulfills a certain condition, like a minimum or a maximum. For example, your products have multiple price fields. To find the maximum value, use
Max, e.g.:$Feed: dimensions | Split {","} | Select {ToDecimal} | Max. In this example,Selectacts on all of the elements within the collection.
Text templates
Text templates let you create dynamic text that automatically pulls in information from your data sources. Text templates are also used to concatenate pieces of text together to form a long text.
To introduce a text template, use backticks `` to enclose the full text. Then, provide placeholders for arguments with double curly braces {{ }}. You must convert all non-text values to text format to print them within your text template. E.g.: `Hello, {{$Feed:Name}}, you are {{$Feed:age}} years old `.
Invoking actions
You can perform various actions on your data, such as changing the text case. E.g.: $Feed: Title | ToTitle converts Title to title case.
Or you can chain different actions together. To create a pipeline (action chain), separate each new action with a pipe ( | ). The output of the previous action is then used as the input for the next action. E.g.: $Feed: Title | ToUpper | Trim first converts Title to uppercase and then trims whitespace.
- Some actions, such as replacement or multiplication, require an argument – an input for the action. To introduce an argument, use curly braces { }. If the argument type is text, enclose it in quotation marks " ". E.g.:
$Feed: Description | Replace {"Red"; "Green"}replaces 'Red' with 'Green' in Description. For any other data type, no quotation marks are needed. E.g.:$Feed: Price | ToDecimal | Multiply {4}. You can use a field from another data source in your argument. In that case, reference that field with the appropriate variable syntax. E.g.:
$Feed: Description | Replace {"Red"; $Feed: Color}replaces 'red' with a value in the Color field taken from your product feed.You can nest other actions directly within the argument to modify the value referenced in that argument. E.g.:
$Feed: Price |ToDecimal |Divide {$Feed: Discount | ToDecimal | Ceiling}divides the Price by the value in Discount. Discount was rounded up to the next whole number.
Actions
Below is the library of CE Shell’s actions.
Converting to a different type
ToDecimal
Description: converts the input value to a decimal. For the conversion to work, the input value must be a valid number, e.g.: 3.123 or 42. If the value cannot be converted, you receive an error, e.g.: [input] is not a valid decimal. You can convert the value to a decimal to use mathematical actions.
Supported input types: text, integer
Example:
- Input (Age): 42.30
- Action:
$Feed: Age | ToDecimal | Multiply {2} - Output: 84.60
ToInteger
Description: converts the input value to integer. For the conversion to work, the input value must be a whole number, e.g.: 42 or -42. If the value cannot be converted, you receive an error, e.g.: [input] is not a valid integer. You can convert the value to integer to use mathematical actions.
Supported input types: text
Example:
- Input (Age): 42
- Action:
$Feed: Age | ToInteger | Multiply {2} - Output: 84
ToText
Description: converts the input value to text. This action is a requirement for CE Shell used on a custom field for product feed mapping. Make sure to add it at the end of the advanced rule so that ChannelEngine can interpret the value as text. E.g.: $Feed: Price | ToDecimal | Divide {3} | ToText.
Supported input types: integer, decimal, boolean
Example:
- Input (Age): 42
- Action:
$Feed: Age | ToText - Output: 42
TryToDecimal
Description: attempts to convert the input value to a decimal, similar to ToDecimal. If the value cannot be converted, it returns ‘null’.
Supported input types: text, integer
Example:
- Input (Age): forty-two and a half
$Feed: Age | TryToDecimal- Output: null
TryToInteger
Description: attempts to convert the input value to an integer, similar to ToInteger. If the value cannot be converted, it returns ‘null’.
Supported input types: text
Example:
- Input (Price): forty-two
$Feed: Price| TryToInteger- Output: null
Boolean actions
These actions return either true or false as long as the condition is met. Such actions are known as boolean.
IsBlank
Description: returns true if the input value is blank (i.e.: is null, contains only whitespace characters, or is an empty string). Whitespace characters can be spaces, tabs, line breaks, and carriage returns.
Supported input types: text
Example:
- Input: ""(raw value)
- Action:
""| IsBlank - Output: True
IsWhitespace
Description: returns true if the input value contains only whitespace characters. These can be spaces, tabs, line breaks (newlines), and carriage returns.
Supported input types: text
Example:
- Input: " " (raw value)
- Action:
" "| IsWhitespace - Output: True
IsEmpty
Description: returns true if the input value is an empty string ("").
Supported input types: text
Example:
- Input: "" (raw value)
- Action:
""| IsEmpty - Output: True
IsNull
Description: returns true if the input value is null. Null is the absence of a value. Null is also a result of an action, such as TryToDecimal and TryToInteger, if those cannot convert the input value to a decimal or integer, respectively.
Supported input types: text, integer, decimal, boolean
Example:
- Input:
not-a-number - Action:
"not-a-number" | TryToInteger | IsNull - Output: True
IsInteger
Description: returns true if the input value is or can be converted to an integer. Otherwise, it returns false.
Supported input types: text
Example:
- Input (Discount): 20
- Action:
$Feed: Discount| IsInteger - Output: True
IsDecimal
Description: returns true if the input value is or can be converted to a decimal. Otherwise, it returns false.
Supported input types: text
Example:
- Input (Price): 20.59
- Action:
$CE: Price| IsDecimal - Output: True
Not
Description: negates the boolean action. If the result of the boolean action is true, Not changes it to false, and vice versa.
Supported input types: boolean
Example:
- Input (Description): This is a comfy yoga mat.
- Action:
$Feed: Description | Not {EndsWith {"mat."}} - Output: False
Equals
Description: returns true if the input value is equal to the one you provided in the curly braces { }. Text values are case sensitive.
Supported input types: text, integer, decimal, boolean
Example:
- Input (Brand): Nitro
- Action:
$Feed: Brand | Equals {"Nitro"} - Output: True
StartsWith
Description: checks if the input value starts with given characters. Specify at least one character as an argument.
Supported input types: text
Example:
- Input (Brand): Nitro
- Action:
$Feed: Brand | StartsWith {"Ni"} - Output: True
EndsWith
Description: checks if the input value ends with given characters. Specify at least one character as an argument.
Supported input types: text
Example:
- Input (Brand): Nitro
- Action:
$Feed: Brand | EndsWith {"ro"} - Output: True
GreaterThan
Description: checks whether the input value is greater than a number or the value of another field.
Supported input types: integer, decimal
Example:
- Input (Price): 35.99
- Action:
$Feed: Price | ToDecimal | GreaterThan {35} - Output: True
LessThan
Description: checks whether the input value is less than a number or the value of another field.
Supported input types: integer, decimal
Example:
- Input (Price): 35.99
- Action:
$Feed: Price | ToDecimal | LessThan {35} - Output: False
Setting up a condition
WhenBlank
Description: falls back to the value provided in the curly braces { } as long as the input value is blank (i.e.: is null, contains whitespace characters, or is an empty string). The fallback value must be of the same type as the input value, i.e.: text.
Supported input types: text
Example:
- Input (Name):
- Action:
$Feed: Name | WhenBlank {"Is blank"} - Output: Is blank
WhenWhitespace
Description: falls back to the value provided in the curly braces { } as long as the input value contains only whitespace characters. These can be spaces, tabs, line breaks (newlines), and carriage returns. The fallback value must be of the same type as the input value, i.e.: text.
Supported input types: text
Example:
- Input: " " (raw value)
- Action:
" " | WhenWhitespace {"Has whitespace"} - Output: Has whitespace
WhenEmpty
Description: falls back to the value provided in the curly braces { } as long as the input value is empty. The fallback value must be of the same type as the input value, i.e.: text.
Supported input types: text
Example:
- Input: "" (raw value)
- Action:
"" | WhenEmpty {"Is empty"} - Output: Is empty
WhenNull
Description: falls back to the value provided in the curly braces { } as long as the input value is null. The fallback value must be of the same type as the input value.
Supported input types: text, integer, decimal, boolean
Example:
- Input: "25.5" (raw value)
- Action:
"25.5" | TryToInteger | WhenNull {26} - Output: 26
Updating text values
Replace
Description: replaces all occurrences of the input value with the value you provide. If the value to be replaced is not found, it remains the same. It is case-sensitive.
Supported input types: text
Example:
- Input (Name): Nitro Smartphone 2024
- Action:
$Feed: Name | Replace {"Smartphone";"Phone"} - Output: Nitro Phone 2024
ToUpper
Description: converts all letters in text to uppercase.
Supported input types: text
Example:
- Input (Name): Nitro Smartphone
- Action:
$Feed: Name | ToUpper - Output: NITRO SMARTPHONE
ToLower
Description: converts all letters in text to lowercase.
Supported input types: text
Example:
- Input (Name): Nitro Smartphone
- Action:
$Feed: Name | ToLower - Output: nitro smartphone
ToTitle
Description: converts all letters in text to title case.
Supported input types: text
Example:
- Input (Name): nitro smartphone
- Action:
$Feed: Name | ToTitle - Output: Nitro Smartphone
Trim
Description: removes whitespace at the beginning and end of text.
Supported input types: text
Example:
- Input (Name): Nitro Smartphone
- Action:
$Feed: Name | Trim - Output: Nitro Smartphone
Extract
Description: extracts text that complies with the specified regular expression. E.g.: $Feed: Description | Extract {"([A-Za-z]+)"; 1} extracts the first word of the Description field. Enclose every capture group in brackets () and indicate the group number after the semicolon (;). This allows you to extract a single capture group. If you want to extract the text that complies with the whole regular expression, use zero (0) as your capture group number. Extracting and altering text requires knowledge of regular expressions.
Supported input types: text
Example:
- Input (Name): Nitro Smartphone
- Action:
$Feed: Name | Extract {"[A-Za-z]+";0} - Output: Nitro
Remove
Description: removes all occurrences of the text. If the text to be removed is not found, the value remains the same. You can use this action to remove specific words from descriptions for marketplaces.
Supported input types: text
Example:
- Input (Name): Nitro Smartphone
- Action:
$Feed: Name | Remove {"phone"} - Output: Nitro Smart
TakeLeft
Description: extracts the given number of characters from the left side of the text. You can use this action to create short descriptions with a maximum number of characters.
Supported input types: text
Example:
- Input (Name): Nitro Smartphone
- Action:
$Feed: Name | TakeLeft {7} - Output: Nitro S
TakeRight
Description: extracts the given number of characters from the right side of the text.
Supported input types: text
Example:
- Input (Name): Nitro Smartphone
- Action:
$Feed: Name | TakeRight {5} - Output: phone
PadLeft
Description: pads the left side of the text value with a given character until it reaches a given character length. Note that you can use a single character for padding, and it cannot be null. The character length you indicate must be greater than 0 (zero).
Supported input types: text
Example:
- Input (Brand): Nitro
- Action:
$Feed: Brand| PadLeft {"n";5} - Output: Nnitro
PadRight
Description: pads the right side of the text value with a given character until it reaches a given character length. Note that you can use a single character for padding, and it cannot be null. The character length you indicate must be greater than 0 (zero).
Supported input types: text
Example:
- Input (Brand): Nitro
- Action:
$Feed: Brand| PadRight{"o";5} - Output: Nitroo
Ellipsize
Description: cuts the number of characters in the text to the limit you specify and adds ellipsis (...) at the end.
Supported input types: text
Example:
- Input (Description): This is the smartest phone on Earth.
- Action:
$Feed: Description | Ellipsize {7} - Output: This is…
WordWrap
Description: cuts text to the nearest whole word within the character limit you specify, ensuring that words are not awkwardly split. You can use this action to shorten long titles or short descriptions, for which marketplaces have fixed character limits.
Supported input types: text
Example:
- Input (Description): This is the smartest phone on Earth.
- Action:
$Feed: Description | WordWrap {5} - Output: This
Mathematical calculations
Round
Description: rounds the decimal to the specified number of digits after the decimal point. The maximum number of digits you can specify is two. If you enter any number other than ‘1’ or ‘2’, you receive an error. E.g.: $Feed: Price| ToDecimal | Round {2}.
Supported input types: decimal
Example:
- Input (Price): 41.1234
- Action:
$Feed: Price | ToDecimal | Round {2} - Output: 41.12
Ceiling
Description: rounds up the decimal to the nearest whole number.
Supported input types: decimal
Example:
- Input (Price): 41.01
- Action:
$Feed: Price | ToDecimal | Ceiling - Output: 42
Floor
Description: rounds down the decimal number to the nearest whole number.
Supported input types: decimal
Example:
- Input (Price): 41.99
- Action:
$Feed: Price | ToDecimal | Floor - Output: 41
Multiply
Description: multiplies the input value by an integer or a decimal. You can also multiply the input value by a value of a different field.
Supported input types: integer, decimal
Example 1:
- Input (Price): 41.99
- Action:
$Feed: Price | ToDecimal | Multiply {2} - Output: 83.98
Example 2:
- Input: Price: 42; Discount: 0.8
- Action:
$Feed: Price | ToDecimal | Multiply {$Feed: Discount | ToDecimal} - Output: 33.6
Divide
Description: divides the input value by an integer or decimal. You can also divide a field's value by the value of a different field.
Supported input types: integer, decimal
Example 1:
- Input (Price): 42
- Action:
$Feed: Price | ToDecimal | Divide {3} - Output: 14
Example 2:
- Input: Price: 42; Discount: 4
- Action:
$Feed: Price | ToDecimal | Divide {$Feed: Discount | ToDecimal} - Output: 10.5
Add
Description: adds a number to the input value. You can also add a value of a different field to your input.
Supported input types: integer, decimal
Example 1:
- Input (Price): 42
- Action:
$Feed: Price | ToDecimal | Add {3} - Output: 45
Example 2:
- Input: Price: 42; Margin: 3
- Action:
$Feed: Price | ToDecimal | Add {$Feed: Margin | ToDecimal} - Output: 45
Subtract
Description: subtracts a number from the input value. You can also subtract a value of a different field from your input.
Supported input types: integer, decimal
Example 1:
- Input (Price): 42
- Action:
$Feed: Price | ToDecimal | Subtract {3} - Output: 39
Example 2:
- Input: Price: 42; Margin: 3
- Action:
$Feed: Price | ToDecimal | Subtract {$Feed: Margin | ToDecimal} - Output: 39
Working with collections
Split
Description: breaks delimited text into a collection of separate values. Indicate a delimiter, which can be a comma ( , ), a hyphen ( - ), a space, etc.
Supported input types: text
Example:
- Input (Description): This is the smartest, the best phone on Earth.
- Action:
$Feed: Description | Split {","} - Output: a collection of two values – "This is the smartest" and " the best phone on Earth."
ElementAt
Description: returns a specific value from the collection. To specify a value, indicate its position counting from zero (0).
Supported input types: collection
Example:
- Input (Category): Shoes > Sport > Tennis
- Action:
$Feed: Category | Split {">"} | ElementAt {1} - Output: Sport
TryElementAt
Description: attempts to return a specific value from the collection, similar to ElementAt. If the value cannot be returned, it returns ‘null’. To specify a value, indicate its position counting from zero (0).
Supported input types: collection
Example:
- Input (Category): Shoes > Sport > Tennis
- Action:
$Feed: Category | Split {">"} | TryElementAt {3} - Output: null
Select
Description: performs an action on each element of the collection and returns the collection. Provide an argument containing one action or the action chain within the curly braces. The action passed in the argument should be in line with the data type. E.g.: multiplication for integers/decimals or trimming for text values.
Supported input types: collection
Example 1:
- Input (USPs): Take sharp photos with the camera. Fully charge your phone in an hour.
- Action:
$Feed: USPs| Split {"."} | Select {Trim | ToLower} - Output: a collection of two values – "take sharp photos with the camera" and "fully charge your phone in an hour"
Example 2:
- Input (Dimensions): 200, 40, 50.
- Action:
$Feed: Dimensions | Split {","} | Select {ToDecimal | Divide {2}} - Output: a collection of three values – 100, 20, and 25.
Filter
Description: filters each element of the collection. Provide an argument containing one action or the action chain within the curly braces. Filter only accepts arguments that return boolean values (i.e.: true or false). As long as the action in the argument returns true, the element stays in the collection.
Supported input types: collection
- Input (Category): Mobiles > Smartphones > Refurbished phones
- Action:
$Feed: Category | Split {" > "} | Filter {EndsWith {"phones"}} - Output: a collection of two values – "Smartphones" and "Refurbished phones"
Max
Description: returns the highest value within a collection of integers or decimals.
Supported input types: collection
Example 1:
- Input (Dimensions): 5, 15, 10
- Action:
$Feed: dimensions | Split {","} | Select {ToInteger} | Max - Output: 15
Example 2:
- Input (Dimensions): 5.8, 15.3, 10.23
- Action:
$Feed: dimensions | Split {","} | Select {ToDecimal} | Max - Output: 15.3
Min
Description: returns the lowest value within a collection of integers or decimals.
Supported input types: collection
Example 1:
- Input (Dimensions): 5, 15, 10
- Action:
$Feed: dimensions | Split {","} | Select {ToInteger} | Min - Output: 5
Example 2:
- Input (Dimensions): 5.8, 15.3, 10.23
- Action:
$Feed: dimensions | Split {","} | Select {ToDecimal} | Min - Output: 5.8
Use cases using specific actions
Commonly used actions
ToDecimal
Use case: Adjust prices, e.g.: set a "Compare at" price at double the base price.
Example:
$Feed: Price | ToDecimal | Multiply {2}
ToInteger
Use case: Calculate how much stock quantity will be used if you put the product as part of a bundle.
Example:
$Feed: StockQuantity | ToInteger | Multiply {2}
ToText
Use case: Convert numeric values into text for channels that only accept text fields.
Example:
$CE: Price | ToText
TryToDecimal
Use case: Handle mixed shipping inputs like "Free shipping" versus numeric costs.
Example:
$Feed: ShippingCost | TryToDecimal
TryToInteger
Use case: Standardize inconsistent pack sizes written as words or numbers.
Example:
$Feed: PackSize | TryToInteger
Boolean actions to verify data
IsBlank
Use case: Identify the missing EANs for products before adding them to Product selections to be exported to a marketplace.
Example:
$Feed: EAN | IsBlank
IsWhitespace
Use case: As a listing manager, identify titles and descriptions that look filled but only contain spaces.
Example:
$Feed: Title | IsWhitespace
IsEmpty
Use case: Create a smart custom field to verify if the stock for a product is available.
Example:
$CE: Stock | IsEmpty
IsNull
Use case: Catch invalid values in numeric fields, like weight.
Example:
$Feed: Weight | TryToDecimal | IsNull
IsInteger
Use case: Validate pack quantity or carton size entries.
Example:
$Feed: QuantityPerPack | IsInteger
IsDecimal
Use case: Confirm prices or measurements allow decimals.
Example:
$CE: Price | IsDecimal
Not
Use case: Exclude titles that don’t meet naming conventions.
Example:
$Feed: Title | Not {EndsWith {"Mat"}}
Equals
Use case: Filter products by exact brand or category.
Example:
$Feed: Brand | Equals {"Nike"}
StartsWith
Use case: Spot SKUs starting with certain prefixes (e.g., supplier codes).
Example:
$Feed: SKU | StartsWith {"ABC"}
EndsWith
Use case: Check if titles end with size/gender markers.
Example:
$Feed: Title | EndsWith {"Men"}
GreaterThan
Use case: Identify luxury products above a price threshold.
Example:
$Feed: Price | ToDecimal | GreaterThan {100}
LessThan
Use case: Flag low-stock products for exclusion in ads.
Example:
$Feed: StockQuantity | ToInteger | LessThan {5}
Conditional fallback actions
WhenBlank
Use case: Replace missing product names with placeholders to avoid blank titles.
Example:
$Feed: ProductName | WhenBlank {"Unnamed product"}
WhenWhitespace
Use case: Clean up descriptions filled only with spaces by inserting defaults.
Example:
$Feed: Description | WhenWhitespace {"No description available"}
WhenEmpty
Use case: Product titles or SKUs can sometimes come through as empty strings. Avoid empty values that marketplaces reject.
Example:
$Feed: SKU | WhenEmpty {"TEMP-SKU"}Prevents listing errors when no SKU is provided.
WhenNull
Use case: Price conversions or parsing errors sometimes result in null. Ensure a safe fallback price is added.
Example:
$Feed: Price | TryToDecimal | WhenNull {0}Ensures products with missing prices don’t break feeds, but instead get flagged with "0" for further review.
Updating text values (titles, descriptions, and keywords)
Replace
Use case: Standardize brand or category wording for marketplaces.
Example:
$Feed: Name | Replace {"Smartphone"; "Mobile Phone"}Ensures consistency - ‘Smartphone’ → ‘Mobile Phone’ for Amazon’s keyword alignment.
ToUpper
Use case: Enforce uppercase for certain identifiers like SKU, EAN, or internal codes.
Example:
$Feed: SKU | ToUpperAvoids SKU mismatches due to case sensitivity.
ToLower
Use case: Normalize email addresses or tags in fields.
Example:
$Feed: SellerEmail | ToLowerEnsures ‘John.Doe@Shop.Com’ becomes ‘john.doe@shop.com’ for consistent processing.
ToTitle
Use case: Make product titles marketplace-ready.
Example:
$Feed: Name | ToTitleConverts ‘nitro smartphone case’ → ‘Nitro Smartphone Case’.
Trim
Use case: Clean up imported titles/descriptions with unwanted leading or trailing spaces.
Example:
$Feed: Name | TrimPrevents errors where ' Nike Shoes ' should be ‘Nike Shoes’.
Extract
Use case: Pull model numbers or keywords from descriptions.
Example:
$Feed: Description | Extract {"([A-Z0-9]{6,})"; 0}Extracts product codes like ‘AB12345’ from a long description.
Remove
Use case: Strip competitor brand names from descriptions (some marketplaces forbid them).
Example:
$Feed: Description | Remove {"Samsung"}Transforms ‘Compatible with Samsung’ → 'Compatible with ' to comply with rules.
TakeLeft
Use case: Marketplaces with strict title length limits (e.g., 80 chars on eBay).
Example:
$Feed: Name | TakeLeft {80}Truncates titles to avoid rejection.
TakeRight
Use case: Extract model suffixes from product codes.
Example:
$Feed: SKU | TakeRight {4}From ‘PROD-2024-XL’ → ‘-XL’.
PadLeft
Use case: Normalize SKU formats by adding leading zeros.
Example:
$Feed: SKU | PadLeft {"0"; 8}SKU ‘123’ → ‘00000123’.
PadRight
Use case: Enforce fixed-length field codes.
Example:
$Feed: ColorCode | PadRight {"X"; 5}‘RED’ → ‘REDXX’.
Ellipsize
Use case: Prevent descriptions from exceeding marketplace limits.
Example:
$Feed: Description | Ellipsize {200}Cuts long descriptions safely → ‘This product is designed…’.
WordWrap
Use case: Ensure product highlights don’t break words mid-way.
Example:
$Feed: Highlights | WordWrap {100}Ensures a smooth cut-off for bullet points.
Mathematical calculations (pricing, discounts, and margins)
Round
Use case: Standardize decimal places in prices.
Example:
$Feed: Price | ToDecimal | Round {2}Transforms 41.1234 → 41.12.
Ceiling
Use case: Always round prices up for profit protection.
Example:
$Feed: Price | ToDecimal | CeilingTransforms 41.01 → 42.
Floor
Use case: Always round prices down for marketplace psychological pricing.
Example:
$Feed: Price | ToDecimal | FloorTransforms 41.99 → 41.
Multiply
-
Use case 1: Apply bulk discount.
Example:
$Feed: Price | ToDecimal | Multiply {0.9}Create a bulk discount on the price → 10% off.
-
Use case 2: Convert currency.
Example:
$Feed: Price | ToDecimal |Multiply {1.08}Transforms price → convert EUR → USD.
Divide
Use case: Convert pack prices into unit prices.
Example:
$Feed: PackPrice | ToDecimal | Divide {6}Transforms the price of a pack of 6 items → per-item price.
Add
Use case: Add marketplace commission or fixed handling fee.
Example:
$Feed: Price | ToDecimal | Add {3}Final price = product price + handling fee.
Subtract
Use case: Apply discount or promotion.
Example:
$Feed: Price | ToDecimal | Subtract {5}Apply €5 promotion to all items.
Working with collections (categories, keywords, and fields)
Split
Use case: Break category strings for structured use.
Example:
$Feed: Category | Split {">"}Transforms ‘Shoes > Sport > Tennis’ → collection [Shoes, Sport, Tennis].
ElementAt
Use case: Extract subcategories.
Example:
$Feed: Category | Split {">"} | ElementAt {1}Extracts ‘Sport’.
TryElementAt
Use case: Avoid errors when categories vary in depth.
Example:
$Feed: Category | Split {">"} | TryElementAt {3}Returns null if no 4th level exists.
Select
Use case: Clean all split values at once.
Example: $Feed: Tags | Split {","} | Select {Trim | ToLower}
Makes a collection of clean, lowercase tags.
Filter
Use case: Keep only categories ending with "phones".
Example:
$Feed: Category | Split {">"} | Filter {EndsWith {"phones"}}Leaves only ‘Smartphones' & 'Refurbished phones’.
Max / Min
Use case: Pick the largest/smallest dimension for shipping fields.
Example:
$Feed: Dimensions | Split {","} | Select {ToDecimal} | MaxEnsures correct “longest side” dimension is sent to couriers.
Special characters
If your values contain special characters (that are not alphanumeric), such as curly braces ( { } ), a pipe ( | ), or a space, make sure to properly escape the special character by placing a backslash ( \ ) before the special character.
To escape quotes in your text input, place a backslash ( \ ) before each quotation mark.
E.g.: "Hello \"Quoted Value\"" outputs Hello "Quoted Value".
Similarly, to escape a backtick, place a backslash before the backtick, e.g.: \`. To escape a backslash, place a backslash before the backslash, e.g.: \\.
Comments
0 comments
Article is closed for comments.