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.

Worked example: convert mapped numeric text before finding the highest price

Tested in Make on 28 October 2026. This three-module example uses synthetic data only. It separates extracting a field with map() from converting each value with parseNumber().

Start with a JSON > Parse JSON module and paste this into its JSON string field. Run it once so Make recognises the prices array:

{"prices":[{"amount":"9.95"},{"amount":"12.50"},{"amount":"3.00"}]}

The quotation marks make these amounts text. Add a Flow Control > Iterator and set its Array field to:

map(1.prices; "amount")

Here, 1.prices is the mapped array token from the JSON module; amount is the raw key. The result is the text array ["9.95", "12.50", "3.00"]. The Iterator emits one value per bundle.

Add Tools > Numeric aggregator. Set its Source Module to the Iterator, choose Maximum value (MAX), and use this Value formula:

parseNumber(2.value; ".")

Select the Iterator’s value token in your own scenario: module numbers may differ. The decimal separator is a full stop because the source values use one. When writing a Make blueprint, expressions are wrapped in double braces; in the mapping editor, build the formula with its tokens and functions.

On the test run, the aggregator received all three numeric values and returned result: 12.5. A number does not retain a display-only trailing zero: apply formatNumber() at the presentation step if you need 12.50 as text.

Keep extraction and conversion separate. The second argument of Make’s map() is a field key, not a JavaScript-style callback. Putting parseNumber() there does not create a per-item transformation. An Iterator gives you a clear place to convert each extracted value before numeric aggregation.

What if the input is blank or formatted differently?

• Blank or missing amounts: route them for review or explicitly filter them out before aggregation. Do not silently treat a missing price as zero.
• Comma decimals: use the separator that matches the source convention. A value such as 1,234 is ambiguous until you know whether the comma means a decimal or thousands separator.
• Currency symbols or unexpected text: validate the source format before conversion. Do not strip every non-digit character: that can lose negative signs or decimal separators.

The completed test covers the three clean, full-stop-decimal strings above. Check a representative sample from your own source before running the scenario on live data. See Make’s Math functions reference for numeric conversion and formatting, and the if-function guide for conditional routing.

Download the tested Make blueprint

Use this blueprint to try the three-module example above. It contains only the three sample prices and needs no account connections. No newsletter signup is required.

Download the Make blueprint (JSON, 3 KB)

1. Save the JSON file to your computer. If it opens as text in your browser, use Save As to keep the .json file.
2. Create a new blank scenario in Make. Open the editor's More menu, choose Import blueprint, and select the file.
3. Save the scenario with scheduling left Inactive, then choose Run once.
4. Open the Numeric aggregator's execution result. The expected output is result: 12.5.

I imported this exported blueprint into a separate blank scenario and reran it on 28 October 2026. It returned 12.5 without adding credentials or changing the formulas. Make also supports Paste blueprint from clipboard in the same menu if you copy the entire JSON file.

For more practical examples, join the free newsletter on the homepage. I send occasional emails about automation, AI and finance; you can unsubscribe at any time.

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.