Academy

Unit 1 · Make Intermediate: Advanced Functions

Transforming date and time

13 min read Updated May 21, 2026

Unit introduction

Hello! And welcome to the first unit of our Functions course.

Earlier in the Make Basics learning journey, we introduced formatDate() in the Transforming data using functions course. In this unit we will expand on this knowledge, and you’ll learn how to extract more information from date and times.

Whether you’re working with a team across different time zones or not, you’ll hopefully come across something useful here!

In this unit, we’ll focus on date and time functions so you can learn how to:

  • understand, use and modify date and time values in Make
  • learn how to use a variety of functions to manipulate the date and time

Think of this unit as a few standalone functions that should give you an idea of how to manipulate the date and time a lot more!

Time zone options

First off, let’s start with how to configure time zones. On your Profile → Time Zone options, you can find different time zones. These are for how content is displayed within the Make UI (Web), and how time is processed at an organization level (Scenarios).

Web Time Zone

The web timezone is how date and time values are displayed to you, within Make on your browser, for example, when you process a bundle containing the date. This is the time zone used for dates and times displayed on the Make website.

For example, Paul based in the UK will have a different timezone compared to Bruno, who is in Brazil. If both of them run the same scenario, the dates will be displayed based on the settings in their web timezone.

Scenarios Time Zone

The scenarios timezone is used by any date and time functions, and to schedule scenarios. This is the time zone to be used for parsing and formatting dates and times during the scenario run (if you don’t specify the time zone explicitly). This means these dates and times will be recorded and executed consistently for everybody.

Example

Let’s look at this with an example: Scott is based in New York and has his web timezone set as GMT-05:00.

GMT is a way to coordinate time zones. London is GMT+00:00, and other time zones are expressed as a certain number of hours ahead or behind GMT. In this example, New York is 5 hours behind GMT.

Scott works as part of an organization that is based in Europe, the timezone for their scenarios is GMT+00:00.

If Scott runs a scenario in the Make Academy organization that parses the date (e.g. converts from <text> to <date>) for the date 27/11/2023 at 04:00AM in New York, the browser would display 26 November, 11PM. But if he was in a timezone that is positive to GMT (e.g. Paris GMT +01:00), he’d have the same date, but a slightly different time: 27/11/2023 at 05:00AM.

Note that when parsing dates without hours, Make will default to midnight on the Organization’s timezone, which is GMT+0 in this particular case.

What is the Locale setting?

Another interesting configuration is the Locale option within your Profile settings. This setting determines how dates are displayed in your browser.

For example, if you use English (United Kingdom), you’ll see dates in DD/MM/YYYY format, whereas using English (United States) would show them in MM/DD/YYYY.

Note: The Locale setting only affects how dates are displayed in your browser. It sets environment data formats, hour formats, decimal separators, etc.

Make uses the standard format for date and times: ISO 8601. In practice, this means that the date/time will usually look like this if you inspect their “raw” value: YYYY-MM-DDTHH:mm:ss.sssZ.

This format breaks down as follows:

  • YYYY: Year
  • MM: Month
  • DD: Day
  • T: Date/time separator
  • HH: Hour
  • mm: Minute
  • ss: Second
  • sss: Millisecond
  • Z: Time zone designator

The letter ‘Z’ is used to represent that the time is represented in Coordinated Universal Time (UTC).

For example, November 27th 2023 at 08:30 GMT would be 2023-11-27T08:30:00.000Z. The last 000 is the time in milliseconds, and Z just indicates the date and time is in UTC.

For more information on this topic, you can view unit 4 of Transforming Data using functions in Make Basics.

Let’s see this in action

Start by creating a scenario containing a Parse JSON module, and copy/paste this JSON string: {"date": "2023-11-27T22:00:00.000Z"}.

Based on where you are in the world and your web settings in Make, the output will display differently. When you display the dates of events in Make, it’s automatically converted to your local time for display based on your web setting. If you are in a different timezone to GMT+00:00, the time and the format on the output will not match the input. Make is automatically converting it to display it in the chosen locale format.

GMT+00:00

If you are based in the GMT+00:00 (for example, the UK), the output time will display as 27 November 22:00.

GMT+00:00 includes countries such as the United Kingdom and Ireland.

The input and output would look like this:

INPUT Bundle 1: (Collection) JSON string: { "date": "2023-11-27T22:00:00.000Z" }

OUTPUT Bundle 1: (Collection) date: 27 November 2023 22:00

GMT-08:00

If you are in the GMT-08:00 timezone, the output time will display as 27 November 14:00.

GMT-08:00 includes states in the US such as California, Washington, Oregon, Nevada, Arizona, and some areas of Canada.

The input and output would look like this:

INPUT Bundle 1: (Collection) JSON string: { "date": "2023-11-27T22:00:00.000Z" }

OUTPUT Bundle 1: (Collection) date: 27 November 2023 14:00

GMT+01:00

If you are in the GMT+01:00 timezone, the output time will display as 27 November 23:00.

GMT+01:00 includes countries such as France, Italy, Czechia, Croatia, Germany, and Spain to name a few.

The input and output would look like this:

INPUT Bundle 1: (Collection) JSON string: { "date": "2023-11-27T22:00:00.000Z" }

OUTPUT Bundle 1: (Collection) date: 27 November 2023 23:00

GMT+08:00

If you are in the GMT+08:00 timezone, the output time will display as 28 November 06:00.

GMT+08:00 includes countries such as China, Singapore, Malaysia. Note that as the time is 8 hours ahead, the date has changed from the 27th of November to the 28th.

The input and output would look like this:

INPUT Bundle 1: (Collection) JSON string: { "date": "2023-11-27T22:00:00.000Z" }

OUTPUT Bundle 1: (Collection) date: 28 November 2023 06:00

Now let’s explore a few date and time functions in Make.

Element - Selectable image 3 – modal

Before we start using functions on dates, let’s look at how Make handles dates based on different conditions, such as the data type and the information on dates it receives.

Handling <text> Data Type

Make will try to convert dates automatically into a format that is readable and logical. However, in some cases, dates are written as a <text> data type. Mapping a <text> data type into a field that expects a <date> data type may lead to errors.

This can be resolved by using a parseDate() function, which converts the data type of the date string from <text> to <date>. This function also allows you to specify the format of the output, for example, in DD/MM/YYYY, similar to formatDate().

parseDate( date ; DD/MM/YYYY )

Handling Dates Without Time

It’s important to note that midnight is a default in Make if no time is provided. Make will then parse dates as if they are in your organization’s timezone, not your web timezone.

Consider the following example settings:

  • Web timezone = GMT+09:00
  • Organization timezone = GMT+00:00
  • Input: 27/11/2023

The following scenarios illustrate how Make handles this:

  • If the web and organization timezones were the same, Make would provide the output time as 00:00.
  • If the web timezone were New York (GMT-05:00), but the organization were set to London time, this would provide a time output of the 26th November, which is 5 hours behind the organization timezone.

It’s also important to use the correct tokens with the parseDate() function and formatDate() functions: MM means month but mm means minutes!

Date time variables

So far we’ve been looking at timedates in ISO format. But Make can actually accept dates in different formats too: timestamp variables. These are alternatives for manipulating the time.

Let’s explore what each of these does, and how they could be useful within Make.

Now

You have encountered the now variable if you are up to date with the Academy content – this will provide a timestamp of the date and time where you are now.

In Make, date and times will always be stored up to milliseconds. So if you type 2023-11-27, that would become 2023-11-27T00:00:00.000Z, as Make attempts to convert the text into a <date> format automatically. It will be parsed in your organization’s timezone though, so your time may vary.

This is the most commonly used option.

now is a very easy date/time format to manipulate when compared to timestamp, and may be more useful for you when you need to log an event. Think of this as writing in a diary:

“Paul completed a Make Academy course on 12-12-2023 12:00”.

Timestamp

Timestamps are a bit different. They count the seconds that have passed since January 1st 1970 midnight GMT, which is the modern “zero-hour” for computers, also called the epoch time.

Think of these as putting a label on an event to say exactly when it happened. You will have encountered this in numerous ways, e.g. when you take a picture with your camera, or create a post on social media, each will have a timestamp.

Timestamps are represented as a numerical value and a <number> data type, for example 1702631664.

These values can also be used to measure the amount of time between 2 timestamp values, or “events”, using math functions within Make.

This is calculated by timestamp#2 - timestamp#1.

Use case

Let’s look at how you can use some new date and time functions and the now variable to set a date/time of a specific day. Work through each stage before you continue.

Ivana works in HR at her company and is responsible for issuing invoices. She needs to create a scenario to issue invoices with an ‘issued date’ for the first day of each month.

Let’s utilize some of date and time functions to manipulate this date, and create a variable that can be added to an invoicing module.

The best way for Ivana to get this result is to combine functions and to use the now variable, as this will provide the date in her local timezone/settings as discussed earlier. For example, 1 January 2024 08:00.

The image displays how the finished result will look. However, we’ll break this down into smaller steps over the next few pages.

The easiest way to achieve Ivana’s goal is to add a month to the current date, then set the day (with setDate, not setDay) to 1, and the hour and minutes to 08:00.

This will take the now variable, and use various functions to output a <date> type that displays the first day of the next month.

If you would like to attempt this exercise, open Make and create a scenario named Make Intermediate C6 U1.

The finished result using a nested function would look like this: setMinute( setHour( setDate( addMonths( now ; 1 ) ; 1 ) ; 8 ) ; 0 )

Let’s break this down into individual functions, rather than a nested function:

Add a month

Add a Set variable module and name the variable Add_1_month.

In Variable value, use the following function: addMonths(now;1). This will add one month to the current date.

As an example, the output of this would take the current value of now, for example the 4 December 2023 15:30 and transform this to 4 January 2024 15:30.

Set the day to the 1st

Add another Set variable module. Under Variable name write Set_1st_date.

In Variable value, insert setDate() and map the Add_1_month variable. This will change the date of your value to whichever date that you specify. For example:

setDate(4 January 2024 15:30; 1)

This will adjust the value of the date of the current time, and would therefore display as 1 January 2024 15:30.

Set the hour to 8

Next, you’ll adjust the first hour of the variable. Add another Set variable module and name it Set_hour_to_8.

In Variable value, insert setHour() and map the Set_1st_date variable. The hour value can be adjusted based on what you insert after the ; symbol. For the purpose of this exercise, put 8 here.

This will modify the date/time to 1 January 2024 08:30.

Note: It is only adjusting the hour value, rather than minutes. Let’s fix that!

Set the minute to 0

Finally, add one last Set variable module. Name it Set_minute_to_0.

In Variable value, insert setMinute() and map the Set_hour_to_8 variable.

As expected this will allow you to specify the minute. Put 0 after the ; symbol.

Therefore 1 January 2024 08:30 would be transformed to 1 January 2024 08:00.

Click Run once and see if this has worked! You can access the blueprint to compare:

  • ZIP file
  • JSON code

Element - text / text and image (Portrait) - LARGE

The approach to using multiple Set Variable modules is less efficient than nesting multiple functions. But splitting this into four separate functions should give you a good idea of how modifying the original now variable step by step works!

  • setMinute( ; 1 )
  • setHour( ; 1 )
  • setDate( ; 8 )
  • addMonths( now ; 0 )

This can be optimized as shown earlier to achieve the same end result, but with few credits consumed, less variables created, and hopefully a tidier scenario!

If you have followed the steps properly, you should have a similar end result that Ivana is trying to achieve: a value that can be mapped to her invoicing software that will insert the value of the first date of next month at 08:00.

OUTPUT
Bundle 1: (Collection)
Set_minute_to_0: 1 January 2024 08:00

Note: This content was created in December 2023, so output here displays 1 January 2024 08:00.

Element - text / text and image (Portrait) - LARGE

That’s everything we’re going to cover in date and time functions.

This should give you a good idea of how you can manipulate the date within Make to suit your needs. Let’s have a quick recap:

  • The Web timezone shows how date and time values are displayed to you, on your browser.
  • The Scenario timezone is the timezone used by functions, and when scenarios are scheduled for.
  • Make will try to convert dates automatically, but it’s better to be safe using parseDate().
  • Make can also accept dates in different formats in the form of now and timestamps.
  • You can combine functions in order to manipulate the date/time.