Mastering Dates and Time in Make.com: A Practical Guide for Automation Builders

Here’s what each part means:

• T separates the date and time.

• Z stands for UTC.

• .SSS indicates milliseconds.

You might also encounter Unix Timestamps, which represent time in seconds or milliseconds since January 1, 1970 (UTC) — known as the Unix epoch.

Unix timestamps are especially useful when integrating with APIs or databases that expect numeric time values instead of strings.

3. The Relationship Between Web and Scenario Time Zones

Here’s where things get tricky — the difference between the web and scenario layers.

Let’s visualize it with an example:

So, if your web time zone and scenario time zone are different, you might see a mismatch — a common cause of “off-by-5-hours” errors.

To fix this:

• Align your Account and Scenario time zones.

• Or, explicitly specify a time zone in your parseDate() and formatDate() functions.

That way, Make won’t make assumptions about what you meant — you’ll be in control.

4. The parseDate() Function

Let’s talk about the hero of the story: parseDate().

Definition

parseDate() converts a piece of text into a Make-compatible date object, following the ISO 8601 standard. It’s like telling Make, “Hey, this text here is actually a date — please treat it as one.”

Make interprets this date using your scenario’s default time zone.

Example 2: Parsing with Time Zone

This version explicitly tells Make the source is from New York time.
Make then converts it into UTC internally — so when you use or display it later, everything stays consistent across different users and regions.

5. Daylight Saving and Consistency Tips

Daylight Saving Time (DST) is one of the biggest culprits behind time errors in automations.

For example, Los Angeles alternates between UTC−7 and UTC−8 throughout the year. That shift can cause your automations to trigger an hour early or late if not handled carefully.

To avoid these headaches, I often use non-DST time zones like:

My recommendation: Pick a stable time zone such as Asia/Kolkata or Africa/Tripoli in both your account and scenario settings. This keeps all timestamps consistent year-round — no surprises in March or October.

6. The formatDate() Function

Once you’ve parsed a date, the next step is usually to display it — and that’s where formatDate() comes in.

Definition

formatDate() takes a Make-compatible date object and converts it into readable text — formatted your way.

Parameters

Example

Output:

This gives you a clean, human-readable timestamp you can send to a CRM, Google Sheet, or Slack message.

7. Common Date Tokens in Make

Make.com uses tokens to define how dates are parsed or displayed.
Here’s a quick cheat sheet:

If you ever get stuck, Make’s built-in reference is your friend:
Help → Functions → Date & Time → Tokens for Parsing/Formatting

8. Working with Epoch / Unix Timestamps

Some systems — especially APIs and databases — use Epoch (Unix) time to store dates.

These timestamps measure the number of seconds or milliseconds since January 1, 1970 UTC.

Example

Output:

That’s how I usually normalize timestamps from APIs like Shopify, HubSpot, or Stripe before sending them into a readable format inside Make.com.

9. Best Practices for Working with Dates in Make

Over the years, I’ve collected a few best practices that save time and debugging effort:

• Always confirm your source time zone.
  Before parsing, know where your data is coming from — CRM, form tool, or API.
• Use parseDate() before formatting.
  Never format raw text; it must be parsed into a date object first.
• Align your account and scenario time zones.
  Keep both the same to prevent mismatched output.
• Prefer non-DST zones for consistency.
  Choose stable zones like Asia/Kolkata to avoid seasonal shifts.
• Double-check your tokens.
  Using D instead of M can break parsing completely.

Following these steps has helped me eliminate 90% of date-related issues in Make scenarios.

10. Quick Reference Workflow

Let’s tie everything together with a simple workflow example.

Input

Step 1: Parse

Step 2: Convert / Adjust (Internal)

Make automatically converts this to UTC.

Step 3: Format

Output

Everything stays accurate, clear, and timezone-safe — ready for export, logging, or triggering other automations.

Final Thoughts: Simplifying Time in Make.com

Working with dates and times in Make.com can feel overwhelming at first, but once you understand how parseDate() and formatDate() interact with time zones, it becomes second nature.

Remember, time data flows through two layers (web and system), and your goal is simply to keep them in sync. From there, you can build scenarios that run smoothly across time zones — whether you’re automating reminders for global teams or syncing transactions between systems.

If you’d like to explore more about custom Make.com automations or learn how to integrate AI-powered workflows, check out our other guides like AI Automation for Small Businesses or Custom AI Automation Agency.

And if you ever get stuck, feel free to contact us for a quick automation consultation — we’ve helped dozens of teams make sense of time (literally).