Seconds Since 1970
At build time, 1,778,313,484 seconds had elapsed since the Unix epoch. The counter below updates in real time.
| Total Milliseconds | 1,778,313,483,000 |
What Are Seconds Since 1970?
Seconds since 1970 refers to the total number of seconds that have elapsed since midnight Coordinated Universal Time (UTC) on January 1, 1970. This starting point is known as the Unix epoch, and the resulting integer is called the Unix timestamp, epoch time, or POSIX time. Rather than encoding dates as separate fields for year, month, day, hour, minute, and second, epoch time collapses everything into a single continuously incrementing number. At the moment the epoch began, the counter was zero. One minute later it was 60. One hour later, 3,600. One full day later, 86,400. The counter has been ticking ever since, and today it stands at well over one and a half billion.
This raw integer representation of time has become the universal standard in computing. Every major operating system, programming language, database engine, and network protocol either uses epoch seconds natively or provides built-in functions for converting to and from it. Its simplicity is its greatest strength: comparing two moments in time is nothing more than comparing two integers, and calculating the duration between them requires only subtraction.
Why 1970 Was Chosen
The choice of January 1, 1970 as the epoch was made by Ken Thompson and Dennis Ritchie at Bell Labs during the development of the Unix operating system. In the late 1960s and early 1970s, Thompson and Ritchie were building Unix on the PDP-7 and later the PDP-11, machines with extremely limited resources by modern standards. Memory was measured in kilobytes, and the processor word size was typically 16 or 32 bits. They needed a compact way to represent time, and a single integer counting seconds was the simplest possible scheme.
The epoch date needed to be recent enough that the resulting numbers would remain small and fit comfortably within the available integer sizes, but early enough to be useful for representing dates in the recent past. Since Unix development began around 1969 and 1970, the start of that year was a natural and convenient anchor point. There is nothing astronomically or historically significant about January 1, 1970; it is purely a convention that the computing world agreed upon and has never had reason to change.
Early versions of Unix actually used a different epoch and counted time in sixtieths of a second, but the system was quickly simplified to count whole seconds from the 1970 epoch. This pragmatic decision, made over fifty years ago in a New Jersey research lab, now underpins virtually all digital timekeeping on Earth.
The Scale of Epoch Time
The Unix timestamp has passed several notable milestones since 1970. On September 9, 2001, at 01:46:40 UTC, the counter reached exactly 1,000,000,000 — one billion seconds. This event was celebrated by programmers worldwide with "billion-second parties." On November 14, 2023, the timestamp crossed 1,700,000,000. Looking ahead, the counter will reach 2,000,000,000 on May 18, 2033, and shortly after that, on January 19, 2038, it will hit 2,147,483,647 — the maximum value of a signed 32-bit integer and the trigger for the well-known Year 2038 problem.
To put these numbers in human perspective: one million seconds is about 11.5 days. One billion seconds is roughly 31.7 years. The current epoch time, in the range of 1.7 to 1.8 billion, represents over 56 years of accumulated seconds. By the time a child born today reaches retirement age, the Unix timestamp will have surpassed 3.5 billion — a number that would be unrepresentable on the 32-bit hardware that first gave rise to the system.
Historical Context
The story of epoch time is inseparable from the story of Unix itself. In 1969, Ken Thompson wrote the first version of Unix on a spare PDP-7 at Bell Labs in Murray Hill, New Jersey. The PDP-7 was already an aging machine by the standards of the time, with only 8K words of 18-bit memory. Dennis Ritchie joined the effort, and together they convinced Bell Labs management to procure a PDP-11, a more capable 16-bit minicomputer that would become Unix's primary platform for the next decade.
On these machines, every byte mattered. Storing dates as structured records with separate fields for year, month, day, hour, minute, and second would have been wasteful. A single 32-bit integer was far more efficient and made date arithmetic trivial. The decision to count seconds rather than milliseconds or some other unit was driven by the same minimalism: second-level granularity was sufficient for file timestamps and process scheduling, and it kept the numbers smaller.
The 32-bit constraint that seemed perfectly adequate in 1970 — allowing dates up to the year 2038 — was a horizon so far in the future that it felt like eternity to engineers working on hardware that might be obsolete in five years. Yet here we are, with the 2038 deadline now just over a decade away, and the legacy of that original design choice still embedded in billions of devices worldwide.
Seconds vs Milliseconds vs Nanoseconds
Not all timestamp systems use the same unit of precision. The classic Unix timestamp counts seconds and is currently a 10-digit integer. This is the format used by most Unix and Linux system calls, by PHP, by Python's time.time() (as a float with fractional seconds), and by PostgreSQL's EXTRACT(EPOCH FROM ...).
JavaScript and Java use millisecond timestamps — 13-digit integers that provide 1/1000th-of-a-second precision. JavaScript's Date.now() returns milliseconds directly, which is a common source of confusion when interacting with systems that expect seconds. Dividing by 1,000 and flooring the result converts a millisecond timestamp to a standard Unix timestamp.
At the other end of the spectrum, languages like Go and Rust and domains like high-frequency trading use nanosecond timestamps — 19-digit integers offering billionth-of-a-second precision. These are essential when measuring code execution time, network latency, or the ordering of events that occur within microseconds of each other. Linux's clock_gettime() system call can return nanosecond-resolution timestamps, and modern hardware timing sources like Intel's TSC (Time Stamp Counter) operate at even finer granularity.
When working across systems, always verify whether a given timestamp is in seconds, milliseconds, or nanoseconds. A quick rule of thumb: 10 digits means seconds, 13 digits means milliseconds, and 16 or more digits likely means microseconds or nanoseconds. Misinterpreting the unit will produce dates that are either thousands of years in the future or just hours after the 1970 epoch.
Frequently Asked Questions
How many seconds have passed since 1970?
As of this page's last build, approximately 1,778,313,484 seconds have elapsed since January 1, 1970 at 00:00:00 UTC. The live counter at the top of this page shows the real-time value, which increases by one every second — or by 86,400 every day.
Why is 1970 the starting point for epoch time?
The Unix epoch was set to January 1, 1970 by Ken Thompson and Dennis Ritchie at Bell Labs. They needed a starting point close to when Unix was being developed that would produce small integers on the 32-bit PDP-series hardware they were using. The date has no special astronomical or historical significance — it is simply a shared convention that the entire computing industry adopted.
When did the Unix timestamp reach 1 billion?
The Unix timestamp reached 1,000,000,000 on September 9, 2001, at 01:46:40 UTC. Programmers around the world held "billion-second parties" to mark the occasion. The next major milestone, 2,000,000,000, will occur on May 18, 2033.
What is the difference between seconds and milliseconds in timestamps?
A standard Unix timestamp counts seconds since 1970 and is currently 10 digits long. JavaScript and Java use millisecond timestamps (13 digits) that include sub-second precision. Multiply seconds by 1,000 to get milliseconds; divide milliseconds by 1,000 and discard the remainder to get seconds.
What happens when the timestamp reaches its 32-bit limit?
On January 19, 2038 at 03:14:07 UTC, the Unix timestamp will reach 2,147,483,647 — the maximum value of a signed 32-bit integer. Systems still using 32-bit time storage will overflow, interpreting the date as December 13, 1901. Modern 64-bit systems are not affected, as a 64-bit timestamp can represent dates billions of years into the future.
Do seconds since 1970 include leap seconds?
No. The POSIX standard defines every day as exactly 86,400 seconds. When the international timekeeping community inserts a leap second, Unix systems either repeat a second or smear the adjustment. This means epoch time is not a perfect count of physical SI seconds, but it keeps the arithmetic simple and predictable for software.