String Functions in Make.com: A Practical Guide to Cleaning and Transforming Data

What string functions do in Make.com

Make.com string functions are expressions that operate on text values mapped from earlier modules or entered as literal values. You can use them in module fields, filters, routers, variables and other places where Make.com accepts mapped data or formulas.

Common jobs include:

• Removing leading, trailing or unwanted characters
• Changing text to lowercase or uppercase for consistent comparison
• Combining separate values into a label, message or identifier
• Extracting part of a value based on a position or delimiter
• Checking whether a value contains a word or phrase
• Converting delimited text into an array, or joining array items into text

Choose the function by the data problem

Start with the shape of the input and the shape required by the next step. The same text field may need different treatment depending on whether it is used for display, matching, routing or storage.

Core Make.com string functions and patterns

trim() for removing unwanted spaces

Use trim() when values may contain spaces at the beginning or end. Form submissions, copied data and spreadsheet cells commonly create this problem.

For example, a mapped value can be normalized before a comparison:

trim(mapped_name)

Trimming is not the same as cleaning every internal space. A value such as a name with two words still contains a meaningful space between those words. If internal characters also need to change, apply a separate replacement rule and test it against real input.

lower() and upper() for consistent comparisons

Case conversion is useful when letter case has no business meaning. Email addresses, country codes, status values and system identifiers are common examples, although the correct treatment depends on the receiving application.

A typical filter pattern is conceptually:

lower(trim(status)) = “approved”

Normalize both sides of a comparison where appropriate. Changing only the incoming value while leaving the comparison value inconsistent can make the rule difficult to understand.

concat() for combining fields

Use concat() to combine multiple text values, such as a first name and last name, a prefix and record number, or several parts of a notification.

Conceptually:

concat(first_name; ” “; last_name)

Define what should happen when one input is empty. Otherwise, the result may contain an extra separator or an incomplete identifier. When the output becomes important to later steps, it is often clearer to prepare each component in a variable before assembling the final string.

replace() for controlled substitutions

Use replace() when a known character or sequence must be changed. Examples include replacing spaces in a phone value, changing a delimiter, or removing a character that an API does not accept.

Replacement rules should be narrow enough to avoid damaging valid data. Replacing every hyphen may be correct for one identifier and wrong for another. Decide whether the rule applies to the entire value, one occurrence or a defined pattern, then test the result.

Extracting, searching and restructuring text

substring-style expressions for fixed positions

When a value has a stable structure, a substring expression can extract characters from a defined starting position and length. This can be useful for a fixed-format reference such as ORD-2026-0001, where the year occupies a known position.

Position-based extraction becomes fragile when the source format changes. If the delimiter or segment length can vary, search for the delimiter or split the value instead of relying only on character positions.

contains() for filters and routes

Use contains() when a route depends on whether a phrase appears inside a larger value. For example, a support message could be normalized and checked for a priority term before it is sent down a particular router path.

Conceptually:

contains(lower(message); “urgent”)

Contains-based routing can produce false matches. A search for “paid” may also match part of another word, and a search for “new” may be too broad for a customer message. Use a more specific condition when the decision has operational consequences.

split() and join() for list-shaped text

Some systems store several values in one text field, such as apple,banana,pear. Use split() with the correct delimiter to turn that text into separate items. After processing the items, use join() to create a destination string in the required format.

1. Inspect the source delimiter, including whether spaces appear after commas.
2. Split the value into an array.
3. Process the items with an iterator or other appropriate module.
4. Join the final values using the delimiter required by the destination.

A list stored as text is not equivalent to a real multi-value field. If downstream reporting, deduplication or filtering depends on individual items, preserve the array for as long as possible and join it only at the presentation boundary.

A reliable sequence for building expressions

Long nested expressions are difficult to inspect because several decisions are hidden in one field. Use a short sequence that makes the data state visible.

Keep the official Make.com function reference open while building an expression. Function names, parameter order and return types matter, and the mapper’s suggestions can help confirm what is available in the current editor.

Debugging string functions in Make.com

When a text expression fails, inspect the value at each stage rather than changing several functions at once. Temporarily store an intermediate result in a variable or map it into a test field so the execution output shows what Make.com actually received.

• Empty input: decide whether the scenario should skip the record, use a fallback, or report the missing value.
• Unexpected type: confirm whether the input is text, an array, a number or a value returned by a previous error path.
• Wrong delimiter: check for commas, semicolons, line breaks or inconsistent spaces before using split().
• Position errors: test substring logic with short and long values, not only one example.
• Over-broad matching: review contains() rules for partial words and unrelated phrases.

Design rules for maintainable Make.com scenarios

String functions are small pieces of logic, but they can influence deduplication, routing, CRM updates and external API calls. Treat them as part of the process design rather than decoration inside a mapping field.

Normalize at a defined boundary. Decide whether the source system, the Make.com scenario or the destination owns data cleanup. Applying different rules in multiple scenarios creates inconsistent records.

Separate display text from control values. A customer-facing label can be formatted for readability, while a status used by a router should remain stable and documented.

Make ownership visible. If a transformation determines whether a record is created, updated or rejected, document the rule where the team responsible for that process can maintain it.

Prefer readable logic over clever logic. A few simple steps are often safer than one deeply nested expression, especially when the scenario will later be changed by someone who did not build it.

Example: normalizing an incoming lead

Consider a hypothetical lead form that sends a status with inconsistent spacing and case, a name split across two fields, and a comma-separated list of interests. A reliable scenario could trim and lowercase the status for routing, concatenate the name for a notification, and preserve the interests as an array until the CRM mapping is complete.

The scenario should also define what happens when the last name is blank, when the interests field contains a different delimiter, or when the status does not match an approved value. Those decisions are more important than the individual functions because they determine whether the automation creates a trustworthy record.

For broader workflow work, the relevant question is usually how the Make.com scenario fits into the surrounding CRM, operations and reporting process. ConsultEvo’s systems and automation services cover that wider design context, while the automation and operations portfolio shows examples of connected systems work.