Convert Unix Timestamp in JavaScript

JavaScript handles Unix timestamps natively through the Date object. The key difference from other languages is that JavaScript uses milliseconds instead of seconds.

Unix Timestamp to Date

JavaScript

// From seconds (standard Unix timestamp)
const timestampSeconds = 1704067200;
const date = new Date(timestampSeconds * 1000);
console.log(date.toISOString()); // "2024-01-01T00:00:00.000Z"

// From milliseconds (JavaScript native)
const timestampMs = 1704067200000;
const date2 = new Date(timestampMs);
console.log(date2.toISOString()); // "2024-01-01T00:00:00.000Z"

Date to Unix Timestamp

JavaScript

// Get current timestamp in seconds
const nowSeconds = Math.floor(Date.now() / 1000);
console.log(nowSeconds); // e.g., 1704067200

// Get current timestamp in milliseconds
const nowMs = Date.now();
console.log(nowMs); // e.g., 1704067200000

// From specific date
const date = new Date('2024-01-01T00:00:00Z');
const timestamp = Math.floor(date.getTime() / 1000);
console.log(timestamp); // 1704067200

Timezone Handling

JavaScript

const timestamp = 1704067200;
const date = new Date(timestamp * 1000);

// UTC
console.log(date.toISOString());
// "2024-01-01T00:00:00.000Z"

// Local timezone
console.log(date.toLocaleString());
// Varies by system timezone

// Specific timezone
console.log(date.toLocaleString('en-US', { 
  timeZone: 'America/New_York' 
}));
// "12/31/2023, 7:00:00 PM"

console.log(date.toLocaleString('en-US', { 
  timeZone: 'Asia/Tokyo' 
}));
// "1/1/2024, 9:00:00 AM"

Using Intl.DateTimeFormat for Formatting

JavaScript

const timestamp = 1704067200;
const date = new Date(timestamp * 1000);

const formatter = new Intl.DateTimeFormat('en-US', {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  hour: '2-digit',
  minute: '2-digit',
  second: '2-digit',
  timeZoneName: 'short',
  timeZone: 'UTC'
});

console.log(formatter.format(date));
// "January 1, 2024 at 12:00:00 AM UTC"

Common Pitfalls

Seconds vs Milliseconds

JavaScript uses milliseconds, not seconds. Forgetting to multiply/divide by 1000 is the #1 mistake.

// ❌ Wrong - treating seconds as milliseconds
new Date(1704067200); // Thu Jan 20 1970 (way off!)

// ✅ Correct - multiply seconds by 1000
new Date(1704067200 * 1000); // Mon Jan 01 2024

Parsing Date Strings

Date string parsing varies by browser. Always use ISO 8601 format for consistency.

// ❌ Ambiguous - may parse differently across browsers
new Date('01/02/2024'); // Jan 2 or Feb 1?

// ✅ Unambiguous ISO 8601
new Date('2024-01-02T00:00:00Z');

DST Transitions

When converting to local time during DST transitions, some local times may not exist or may be ambiguous. Always store and transmit timestamps in UTC.

Edge Cases

JavaScript

// Negative timestamps (before 1970)
const before1970 = new Date(-86400 * 1000);
console.log(before1970.toISOString()); // "1969-12-31T00:00:00.000Z"

// Maximum safe date
const maxDate = new Date(8640000000000000);
console.log(maxDate.toISOString()); // "+275760-09-13T00:00:00.000Z"

// Check for invalid dates
const invalid = new Date('not a date');
console.log(isNaN(invalid.getTime())); // true

Frequently Asked Questions

What is a Unix timestamp in JavaScript?

A Unix timestamp represents the number of seconds (or milliseconds in JavaScript) elapsed since January 1, 1970, 00:00:00 UTC. JavaScript Date objects use milliseconds internally.

Does JavaScript use seconds or milliseconds for Unix timestamps?

JavaScript uses milliseconds. When working with Unix timestamps from other systems (which typically use seconds), multiply by 1000 before passing to the Date constructor.

How do I handle timezone conversion in JavaScript?

JavaScript Date objects are timezone-aware. Use toLocaleString() with a timeZone option to display in specific timezones, or use toISOString() for UTC.

Why is my Unix timestamp showing the wrong date?

The most common issue is mixing seconds and milliseconds. If your timestamp is 10 digits, it is in seconds—multiply by 1000. If it is 13 digits, it is already in milliseconds.