Make.com map() Function: Syntax, Examples, max() & join()

Quick answer: Make.com’s map() function extracts one named field from every collection in a complex array and returns those values as a simple array. Its correct syntax is:

{{map(complex array; key; [filter key]; [allowed values])}}

Unlike JavaScript’s Array.map(), Make’s function does not create a temporary alias and does not accept an arbitrary expression. You supply the source array, the raw name of the field you want, and—optionally—a field and values by which to filter.

What does the map() function do in Make.com?

Make distinguishes between a simple array and a complex array. A simple array contains values such as names, numbers or email addresses. A complex array contains collections, with each collection holding several named fields.

For example, module 4 might output this complex array:

[
  {
    "id": 1,
    "name": "John Smith",
    "email": "[email protected]",
    "destination": "Tenerife"
  },
  {
    "id": 2,
    "name": "Sarah Johnson",
    "email": "[email protected]",
    "destination": "Crete"
  }
]

Using map() with the email key converts that complex array into a simple array containing only the email addresses. Make’s official array-functions documentation defines map() as a function that returns values from a complex array and can optionally filter them.

What is the correct Make.com map() syntax?

{{map(complex array; key; [filter key]; [allowed values])}}

• Complex array: the complete array of collections produced by a module or aggregator.
• Key: the raw field name whose values you want returned.
• Filter key: an optional field against which Make should test each collection.
• Allowed values: one or more optional accepted values, separated by commas.

The key must be its raw variable name, not necessarily the friendly label shown in the mapping panel. Hover over a field in Make to inspect its raw name. Raw names and other parameters are case-sensitive, as explained in Make’s guide to mapping arrays.

How do you extract email addresses with map()?

If module 4 produces an array named array, and each collection contains a raw field named email, use:

{{map(4.array; email)}}

The result is a simple array:

["[email protected]", "[email protected]"]

Select the array token from Make’s mapping panel, then enter the raw key name. Do not add an alias such as a, and do not write a.email. Those patterns belong to JavaScript-style mapping, not Make’s built-in map() function.

If you only need the first mapped email rather than the complete array, wrap the result in first():

{{first(map(4.array; email))}}

How do you combine map() and join()?

map() always returns an array. If the destination field expects one text value—for example, an email, Slack message or CSV field—use join() after mapping.

{{join(map(4.array; name); ", ")}}

With the sample data above, the output is:

John Smith, Sarah Johnson

The order matters: first use map() to extract the names, then use join() to combine that resulting array into text. Calling join() on the original complex array will not reliably produce the readable result you want.

How do you filter values with map()?

The third and fourth arguments let you filter collections while extracting a field. To return email addresses only for people travelling to Tenerife, use:

{{map(4.array; email; destination; Tenerife)}}

Here, email is the field being returned, destination is the field being checked, and Tenerife is the accepted value.

You can supply several accepted values separated by commas:

{{map(4.array; email; destination; Tenerife,Crete)}}

This built-in filter is useful for a straightforward equality check. For more complicated scenario logic, routing or several conditions, use a scenario filter or conditional expression instead. My Make.com if-function guide covers those broader conditional patterns.

How do you use max(map()) in Make.com?

max() can accept an array of numeric values. If module 7 returns an array of invoice collections and each collection contains a Number-typed field named amount, use:

{{max(map(7.array; amount))}}

For this input:

[
  {"invoice": "A", "amount": 125},
  {"invoice": "B", "amount": 360},
  {"invoice": "C", "amount": 90}
]

the formula returns 360. The same pattern works with other documented mathematical array functions, including min(), sum() and average(). Their accepted inputs are listed in Make’s official math-functions reference.

This formula only works predictably when the extracted values are numbers. An empty value, currency-formatted text or a field containing words can prevent a valid numeric result.

Does Make.com use number() or parseNumber()?

Make’s current math documentation lists parseNumber(), not number(), for explicitly parsing a text value as a number. Its syntax is:

{{parseNumber(number; decimal separator)}}

For a mapped text value using a full stop as its decimal separator, the expression is:

{{parseNumber(amount; ".")}}

Insert amount from the mapping panel rather than typing the display label. If your source uses a comma as its decimal separator, supply a comma instead.

Do not try to put parseNumber() in the key position of map(). The key argument must be a raw field name, so this is not a valid way to transform every array member:

{{map(7.array; parseNumber(amount; "."))}}

If every amount arrives as text, convert each scalar value before building the numeric array, or use an Iterator followed by an appropriate aggregator. Make documents how Number, Text, Array and Collection fields behave in its item-data-types guide.

How does map() work with nested arrays?

A nested collection and a nested array are not the same thing. If the required value is inside a collection within each array item, use the raw path Make exposes in the mapping panel, which may use dot notation.

If the child value is itself another array, map() does not recursively process every child array for you. Select the correct child array as the source where possible, or use an Iterator to turn its elements into bundles before aggregating the result you need.

This distinction explains many apparently empty results: the formula may be pointing at the parent collection when the actual values live inside a child array.

Why is map() returning empty values?

1. Check the source type. The first argument must be the complete complex array, not one collection or one bundle.
2. Check the raw key. Hover over the field in Make and use its raw variable name with the correct capitalisation.
3. Check the output type. map() returns an array. Use join() for text or first() when you need one value.
4. Check the data type. max(), sum() and similar functions need numeric values, not formatted currency strings.
5. Check the nesting level. A child array may require an Iterator or a separate mapping step.
6. Run the source module once. Make needs sample output before its array structure and mappable fields can be inspected reliably.

Make.com map() video guide

This walkthrough demonstrates extracting values from a simple collection array, combining mapped values with join(), and working through a nested-data example.

What should you remember about map()?

Start with the complete complex array, identify the raw name of the field you need, and let map() return a simple array. Add the optional filter arguments only when you need an exact field-value match. Then apply a second function—such as join(), first() or max()—according to the final output type.

If your array originates in an incoming API request, first confirm that Make has received and recognised the payload structure. The practical setup in my beginner’s guide to Make.com webhooks explains how to capture sample data before mapping it into the rest of a scenario.