Question 1

How do I convert a Unix timestamp to a human-readable date?

Accepted Answer

A Unix timestamp is the number of seconds (or milliseconds) since the Unix epoch — January 1, 1970 at 00:00:00 UTC. To convert one to a human date, multiply the timestamp by 1000 (if in seconds) to get milliseconds, then pass it to JavaScript's new Date() constructor or your language's equivalent. For example, timestamp 1717200000 → new Date(1717200000 * 1000) → 'June 1, 2024 00:00:00 UTC'. The tricky part is knowing whether your timestamp is in seconds (10 digits) or milliseconds (13 digits) — getting this wrong shifts your date by a factor of 1,000, turning June 2024 into the year 56377. jslet's Unix Timestamp Converter auto-detects the unit: 10-digit timestamps are treated as seconds, 13-digit as milliseconds. It displays the result in both UTC and your local timezone, plus ISO 8601, RFC 2822, and relative time formats ('2 hours ago'). You can paste timestamps from log files, database exports, or API responses.

Question 2

Why does my Unix timestamp show the wrong date? Common conversion mistakes.

Accepted Answer

The three most common Unix timestamp conversion mistakes are: (1) Seconds vs milliseconds confusion — Unix timestamps from databases and system APIs are typically in seconds (10 digits, e.g., 1717200000 = June 2024), but JavaScript's Date constructor and many browser APIs expect milliseconds (13 digits, e.g., 1717200000000). If you feed a seconds timestamp to a milliseconds parser, you get a date near January 1970. If you feed a milliseconds timestamp to a seconds parser, you get the year 56377. Fix: check the digit count — 10 digits = seconds, 13 digits = milliseconds. (2) Timezone offset — a Unix timestamp is always UTC. When you format it, your local timezone offset is applied. If the timestamp represents midnight UTC and you're in UTC-5, the display shows 7:00 PM the previous day. This is correct behavior — the moment in time didn't change, only the local clock representation. (3) Negative timestamps — timestamps before 1970 are negative numbers representing dates going back to year 1. Most converters handle this correctly by using a proleptic Gregorian calendar.

Question 3

What years do Unix timestamps support, and what happens after 2038?

Accepted Answer

A standard 32-bit signed Unix timestamp (the traditional time_t on many systems) can represent dates from December 13, 1901 20:45:52 UTC (timestamp -2,147,483,648) through January 19, 2038 03:14:07 UTC (timestamp 2,147,483,647). After this upper bound, a 32-bit counter overflows to a negative number, jumping back to 1901 — known as the Year 2038 problem, analogous to Y2K. However, modern 64-bit systems use 64-bit timestamps that extend billions of years in both directions, effectively solving the problem at the operating system level. JavaScript's Date object uses 64-bit floating-point milliseconds, supporting years from approximately -271,821 to 275,760. Embedded systems, legacy databases, and 32-bit IoT devices are the remaining 2038 risk surface. In practice, most modern applications are safe — the problem is well-understood and migration to 64-bit time_t has been underway for over a decade. jslet's converter handles the full JavaScript Date range, including pre-1970 dates (as negative timestamps) and post-2038 dates.

1 second	1
1 minute	60
1 hour	3,600
1 day	86,400
1 week	604,800
1 year (365 days)	31,536,000

🟢📖 About Unix Timestamps