How to Parse a JSON Date in JavaScript

When you fetch data from an API, dates are almost always transmitted as strings in a standardized format, most commonly ISO 8601. To work with these dates in JavaScript—for example, to format them for a user or to perform calculations—you must first parse this string and convert it into a native Date object.

This guide will show you how to correctly parse an ISO 8601 date string that you would typically receive in a JSON response. You will learn how the new Date() constructor handles this format automatically and understand the crucial role of timezones in this process.

The Core Problem: Dates in JSON are Strings

The JSON (JavaScript Object Notation) format does not have a native data type for dates. Therefore, when a date is serialized into JSON, it is always converted into a string. The most common and recommended format for this string is the ISO 8601 standard (YYYY-MM-DDTHH:mm:ss.sssZ).

For example, imagine you receive the following JSON from an API. The createdAt property is a string, not a Date object.

{
  "id": 123,
  "user": "Alice",
  "createdAt": "2025-10-20T10:00:00.000Z"
}

note

If you try to call Date methods on data.createdAt, it will fail because it's just a string. You must first parse it.

The Solution: The new Date() Constructor

The new Date() constructor in JavaScript is powerful and is specifically designed to parse the ISO 8601 string format directly. This is the simplest and most reliable way to convert a JSON date string into a usable Date object.

Solution:

const jsonString = `{
  "id": 123,
  "user": "Alice",
  "createdAt": "2025-10-20T10:00:00.000Z"
}`;

// First, parse the entire JSON string.
const data = JSON.parse(jsonString);

// The 'createdAt' property is still a string.
console.log(typeof data.createdAt); 
// Output: string

// Now, pass that string to the Date constructor.
const dateObject = new Date(data.createdAt);

console.log(dateObject);
// Output: Mon Oct 20 2025 06:00:00 GMT-0400 (Eastern Daylight Time)
// (The exact output string depends on your local timezone)

note

The dateObject is now a true JavaScript Date and you can use methods like .toLocaleDateString(), .getFullYear(), or perform date arithmetic with it.

How the new Date() Constructor Parses ISO Strings

The ISO 8601 format (YYYY-MM-DDTHH:mm:ss.sssZ) is an international standard designed to be unambiguous.

• YYYY-MM-DD: The date (year, month, day).
• T: A literal character that separates the date from the time.
• HH:mm:ss.sss: The time (hours, minutes, seconds, milliseconds).
• Z: The timezone designator. A literal Z stands for "Zulu time," which is another name for UTC (Coordinated Universal Time).

The new Date() constructor is built to recognize this format and will correctly parse it into a Date object that represents that exact moment in time.

A Note on Timezones and UTC

It is a universal best practice for servers to send dates in UTC. The Z at the end of the ISO string signifies this. When you parse this string with new Date(), the resulting Date object will correctly represent that point in time.

When you then display that Date object (e.g., with console.log(dateObject) or dateObject.toString()), JavaScript will automatically convert it from UTC to the user's local timezone as configured on their computer.

const isoStringUTC = "2025-10-20T10:00:00.000Z";
const dateObject = new Date(isoStringUTC);

// .toISOString() always shows the time in UTC.
console.log(dateObject.toISOString()); 
// Output: 2025-10-20T10:00:00.000Z

// .toString() shows the time in the user's local timezone.
console.log(dateObject.toString());
// Output: Mon Oct 20 2025 06:00:00 GMT-0400 (Eastern Daylight Time)
// (In this example, the user's timezone is 4 hours behind UTC)

note

This is the correct and desired behavior. You should always store and transmit dates in UTC and only convert them to a local timezone for display purposes.

Common Pitfalls and How to Solve Them

Problem: Using JSON.parse with a reviver

JSON.parse() accepts an optional second argument called a "reviver" function. This function is called for each key-value pair and can be used to transform values on the fly. You can use it to automatically convert date strings into Date objects during parsing.

While powerful, this can be complex. You need a reliable way to identify which string values are dates. A common but fragile way is to use a regular expression.

The Potentially Fragile Solution

const jsonString = `{ "createdAt": "2025-10-20T10:00:00.000Z", "id": 123 }`;
const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;

const data = JSON.parse(jsonString, (key, value) => {
  if (typeof value === 'string' && isoDateRegex.test(value)) {
    return new Date(value);     // Convert matching strings to Date objects
  }
  return value;
});

console.log(typeof(data.createdAt))         // Output: object
console.log(data.createdAt instanceof Date) // Output: true
console.log(data.createdAt);                // Output: Mon Oct 20 2025 06:00:00 GMT-0400 (Eastern Daylight Time)

note

Recommendation: For most applications, it is simpler and clearer to parse the JSON first and then manually convert the specific date fields you need, as shown in the main examples.

Practical Example: Parsing an API Response

This is a typical real-world scenario where you fetch data and need to display a formatted date to the user.

// Simulate an API response
const apiResponse = `{
  "event": "Project Deadline",
  "due_date": "2023-11-15T23:59:59.000Z"
}`;

// --- Your application logic ---
const eventData = JSON.parse(apiResponse);

// 1. Parse the string into a Date object
const dueDate = new Date(eventData.due_date);

// 2. Format it for the user in their local timezone
const options = { year: 'numeric', month: 'long', day: 'numeric' };
const formattedDate = dueDate.toLocaleDateString('en-US', options);

console.log(`The event "${eventData.event}" is due on: ${formattedDate}.`);
// Output: The event "Project Deadline" is due on: November 15, 2023.

Conclusion

Parsing date strings from JSON is a fundamental task that is made simple by JavaScript's built-in capabilities.

• Dates in JSON are always represented as strings, most commonly in the ISO 8601 format.
• The new Date(isoString) constructor is the standard, reliable, and recommended way to parse these strings into Date objects.
• The constructor correctly handles UTC (Z) timezone information, and the resulting Date object will automatically render in the user's local timezone when displayed.

By using the new Date() constructor, you can easily and accurately work with date information from any modern API.