TechCompare LogoTechCompare

What is the Unix epoch? Why computers count seconds from January 1, 1970

Unix timestamps are the simplest way to store and compare points in time across systems. They're timezone-agnostic, monotonically increasing (except for leap seconds), and supported by every programming language and database. Store times as Unix timestamps, display them in the user's local timezone.

Timestamp 0 in Unix time is 00:00:00 UTC on January 1, 1970, the Unix epoch. Every Unix timestamp is the number of seconds that have elapsed since that moment, not counting leap seconds. It's a beautifully simple system: one integer represents any point in time, timezone-independent, sortable, and mathematically trivial to compare.

By TechCompare · Updated

Unix timestamp
0
Seconds since epoch
ISO 8601
1970-01-01T00:00:00.000Z
Thu, 01 Jan 1970 00:00:00 GMT
Category
Fundamentals
Timestamp knowledge base

How this is calculated

The epoch was chosen pragmatically by Unix engineers at Bell Labs in the early 1970s. They needed a round number that was recent enough to keep timestamps small (fitting in a 32-bit signed integer) but far enough in the past to represent dates before the system was written. January 1, 1970, was convenient. The 32-bit signed integer limit (2,147,483,647 seconds) will overflow on January 19, 2038, the Year 2038 problem, which is why modern systems use 64-bit timestamps.

Verdict

The epoch itself was a pragmatic Bell Labs pick (a recent enough round number to fit 32-bit timestamps, far enough back to cover pre-Unix dates) and the integer-as-time model is the elegant win: one number, timezone-independent, sortable, O(1) to compare, supported by every language and database. POSIX defines the day as exactly 86,400 seconds and ignores leap seconds, which keeps the math simple at the cost of a small drift over decades. The 32-bit ceiling hits on January 19, 2038, which is the operational reason modern systems carry 64-bit time_t where the same integer model stretches to roughly 292 billion years in either direction. The principle for storing is the same either way: keep the integer in the database, convert to local time only at the presentation layer, never store local-time strings with implicit timezones.

More Timestamp scenarios

Frequently asked questions

Why is the Unix epoch January 1, 1970?
It was a convenient round number close to when Unix was being developed at Bell Labs. There's no deeper technical reason. January 1, 1970, was a Thursday.
Does Unix time count leap seconds?
No, by convention Unix time ignores leap seconds. When a leap second is added to UTC, Unix timestamps continue counting as if the leap second didn't exist. POSIX defines the day as exactly 86,400 seconds regardless of actual UTC time. This keeps math simple at the cost of small drift over decades.
How do I convert a Unix timestamp to a human-readable date?
Use a built-in function in your language. JavaScript: `new Date(timestamp * 1000).toISOString()`. Python: `datetime.utcfromtimestamp(timestamp).isoformat()`. Go: `time.Unix(timestamp, 0).UTC().Format(time.RFC3339)`. Most languages also have a timezone-aware variant. Always store UTC in your database and convert to local time only at the presentation layer.