Make.com map() Function: Syntax, Examples and parseNumber()

Quick answer: Make.com’s map() function extracts values for a specified key from a complex array and returns them as a primitive array, with optional arguments for filtering the source collections, according to Make’s array-functions reference.

map(complex array; key; [key for filtering]; [possible values for filtering separated by a comma])

Use map() when you need one field from each collection in an array. You can then pass the resulting array to another function such as join(), first() or max(), depending on the output you need.

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

The official Make array-functions documentation says map() takes a complex array and returns a primitive array containing the values of a specified key.

For example, an array could contain:

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

Using map() with the email key converts that complex array into a primitive array containing only the email values.

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

map(complex array; key; [key for filtering]; [possible values for filtering separated by a comma])

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

Make’s documented syntax specifies raw variable names for the key arguments. Copy the raw key from the data structure rather than assuming that the friendly label shown in the mapping panel is the value the formula needs.

Make allows functions to be used in mapping fields to build formulas and transform values, and its functions guide groups them into categories including Array, Math, Text and binary, and Date and time functions.

How do you extract email addresses with map()?

If your complex array is named emails[] and each collection contains a raw field named email, use:

map(emails[]; email)

The result is a primitive array of email values, as described in Make’s official map() examples.

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

first(map(emails[]; email))

The array-functions reference lists first() as returning the first element of an array.

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

Make’s join() documentation says the function concatenates the items in an array into a string and places the chosen separator between them.

join(map(emails[]; email); , )

In this formula, map() extracts the email values before join() turns the resulting array into text. Use this pattern when the receiving field expects one text value rather than an array.

How do you filter values with map()?

The third and fourth map() arguments can filter the complex array before values are extracted, according to Make’s documented syntax.

map(emails[]; email; label; work,home)

This example returns the email value from collections whose label is either work or home.

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.

Can you use max() with map()?

Yes. Make’s max() documentation says it returns the largest number from an array or from individually supplied numbers.

max(map(line_items[]; price))

This pattern can return the largest mapped price when the extracted values are numbers. If the source contains numeric text, blanks or formatted currency, inspect and convert the values before relying on a numeric comparison.

How does parseNumber() relate to map()?

Make documents parseNumber(number; decimal separator) as a Math function that parses a string containing a number and returns a number in its Math functions reference.

parseNumber(1 756,456; ,)

The documented function name is parseNumber, with a capital N, rather than parsenumber or ParseNumber. The official pages do not state that every Make function name is case-sensitive, so the safest approach is to use the exact documented spelling.

If values extracted with map() arrive as numeric strings, use parseNumber() where your formula or scenario structure allows before passing them into max() or another Math function.

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. Use the 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 filter. Confirm that the filter key and accepted values match the source data, including capitalisation.
5. Check the final field. Make sure the destination accepts an array, or convert the result into the required type.

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 primitive array. Add the optional filter arguments only when you need a 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.