What Is Unix Time (Epoch Time)?

What Unix Time Is

Also called epoch time or POSIX time, Unix time is a single integer representing a moment in time as a count of seconds from a fixed starting point: January 1, 1970 at midnight UTC. The number 1780000000 refers to the same instant in every timezone on Earth.

Computers prefer integers over strings. Comparing two Unix timestamps is a single arithmetic operation. Comparing two date strings like “June 4, 2026 9:02 AM EDT” and “2026-06-04T14:02:00+05:30” requires parsing, timezone conversion, and then comparison. Unix time removes all of that.

The timestamp has no timezone of its own. Your device applies one when it displays the value. Here's 1780000000 on four clocks:

Same instant, two different calendar dates depending on where you're reading it. In JavaScript, new Date(1780000000 * 1000) gives you that moment. In Python, datetime.fromtimestamp(1780000000, tz=timezone.utc) does the same.

Doing the Conversion by Hand

A timestamp is days and seconds mixed together, and you can pull them apart with division. Take 1780000000. Dividing by 86,400 (the seconds in a day) gives 20,601 whole days with 73,600 seconds left over.

Counting 20,601 days forward from January 1, 1970 lands on May 28, 2026. The leftover 73,600 seconds is 20 hours, 26 minutes and 40 seconds, so the moment is 20:26:40 UTC, the first row of the table above. Calendar code does exactly this, with the leap-year rules added.

Seconds vs Milliseconds

Traditional Unix timestamps are in seconds (10-digit numbers). JavaScript's Date.now() returns milliseconds (13-digit numbers). This mismatch causes bugs when a JavaScript app passes a millisecond timestamp to a system expecting seconds.

Divide a 13-digit timestamp by 1,000 to get seconds. The digit count is a reliable clue for any date between September 2001 and November 2286. Older timestamps have fewer digits, so a 9-digit value is seconds from before September 9, 2001.

Some languages go finer still. Go's UnixNano() and Python's time.time_ns() return nanoseconds, which are 19 digits long. The epoch time converter auto-detects seconds and milliseconds.

Why January 1, 1970

There was no deep reason. Early Unix kept time as a 32-bit counter ticking 60 times a second, which only lasted about two and a quarter years before overflowing. The starting date moved between early releases (1971 and 1972 were both used), and the system was later changed to count whole seconds to avoid that short-term overflow.

Midnight on January 1, 1970 was picked arbitrarily by the Unix engineers as a convenient round date. It stuck because so much software was built on it.

What Unix Time Doesn't Count

Unix time pretends every day has exactly 86,400 seconds. The POSIX standard says so directly: each day is accounted for by exactly 86,400 seconds. That makes the arithmetic simple, but it means Unix time isn't a literal count of every second that has passed.

When a leap second is added to UTC, the Unix numbers repeat rather than adding an extra one. For most apps this never matters. For systems that need precise intervals across a leap second, it can.

Notable Epoch Values

Y2K38: a signed 32-bit integer overflows one second after 03:14:07 UTC on January 19, 2038, and wraps back to December 1901. Systems that store time in 64 bits are not affected, but older software and embedded devices still using 32-bit fields are at risk. Values before 1970 are negative, and many systems accept them, though support varies, so test before relying on it.

Related Tools & Terms