What happens in 2038?

On January 19, 2038 at 03:14:07 UTC, 32-bit signed integer Unix timestamps will overflow, wrapping to a negative number. This is the Year 2038 problem. Most modern operating systems have migrated to 64-bit timestamps, which will not overflow for approximately 292 billion years.

Does Unix time include leap seconds?

No. Unix timestamps deliberately ignore leap seconds. Each day is treated as exactly 86,400 seconds. This means Unix time can diverge slightly from atomic clock time over long periods, but it keeps calculations simple and consistent.

Unix Timestamp

Q: What is the Unix epoch?

The Unix epoch is January 1, 1970 00:00:00 UTC. All Unix timestamps count seconds elapsed since this moment. It was chosen because 1970 roughly marks the birth of Unix at Bell Labs.

Q: What is the current Unix timestamp?

The current Unix timestamp is the number of seconds since the epoch. It is always changing. You can get it in JavaScript with Math.floor(Date.now() / 1000) or on the command line with date +%s.

The time format used by computers worldwide

The Epoch: January 1, 1970 00:00:00 UTC

1704067200

Current Unix timestamp

What is a Unix Timestamp?

The Unix timestamp (also called epoch time, POSIX time, or Unix time) counts the number of seconds that have elapsed since January 1, 1970 00:00:00 UTC. This reference point is known as the Unix epoch. It does not count leap seconds, so every day is treated as exactly 86,400 seconds.

Unix timestamps are expressed as a single integer, making them extremely compact and easy to store in databases. A timestamp of 0 represents the epoch itself (January 1, 1970). A timestamp of 1000000000 represents September 9, 2001, at 01:46:40 UTC — the moment when the counter first reached one billion seconds.

The format was introduced by Unix engineers Ken Thompson and Dennis Ritchie in the early 1970s. It has since become a de facto standard across operating systems, databases, APIs, and programming languages. Most web services, including REST APIs and message brokers like Kafka, transmit timestamps as Unix integers precisely because they are unambiguous across time zones and locales.

The Year 2038 Problem

Many legacy systems store Unix timestamps as 32-bit signed integers. The maximum value of a signed 32-bit integer is 2,147,483,647. When the clock strikes January 19, 2038 at 03:14:07 UTC, the timestamp will exceed this limit and overflow to -2,147,483,648, wrapping back in time to December 13, 1901.

This is known as the Year 2038 problem (or Y2K38). It can cause crashes, incorrect date displays, and data corruption in software that relies on 32-bit time values. Embedded systems, older Linux kernels, and some industrial control systems are the most at-risk categories.

The good news is that most modern operating systems and programming environments have migrated to 64-bit integers for time storage. A 64-bit signed integer will not overflow until approximately the year 292,277,026,596 — roughly 292 billion years from now. However, developers working with legacy codebases or embedded firmware should audit their systems before 2038 arrives.

Key Dates to Remember

January 1, 1970 — Unix epoch begins
September 9, 2001 — Timestamp reaches 1,000,000,000
January 19, 2038 at 03:14:07 UTC — 32-bit integer overflow
~Year 292 billion — 64-bit integer overflow

Common Unix Timestamp Conversions

Below are well-known Unix timestamps and their corresponding human-readable dates in UTC:

Reference Timestamps

0Thu, Jan 1, 1970 00:00:00 UTC (Epoch)

1000000000Sun, Sep 9, 2001 01:46:40 UTC

1234567890Fri, Feb 13, 2009 23:31:30 UTC

1609459200Fri, Jan 1, 2021 00:00:00 UTC

1700000000Fri, Nov 17, 2023 04:13:20 UTC

1704067200Mon, Jan 1, 2024 00:00:00 UTC

1735689600Wed, Jan 1, 2025 00:00:00 UTC

2147483647Tue, Jan 19, 2038 03:14:07 UTC (Max 32-bit)

How to Convert Unix Timestamps

From Timestamp to Human Date

To convert a Unix timestamp to a readable date, you need to add the number of seconds to the epoch. Most programming languages and command-line tools provide built-in functions for this.

# Command line
date -d @1704067200
date -r 1704067200  # macOS / BSD

# Python
from datetime import datetime
datetime.fromtimestamp(1704067200)

From Human Date to Timestamp

To convert a human-readable date to a Unix timestamp, parse the date and subtract the epoch:

# Python
from datetime import datetime
dt = datetime(2024, 1, 1)
int(dt.timestamp())  # → 1704067200

// JavaScript
Math.floor(new Date('2024-01-01T00:00:00Z').getTime() / 1000)

Online Conversion

For quick one-off conversions, you can use an online tool like the Epoch Converter on this site. Simply paste a timestamp and get the human-readable date instantly.

Unix Timestamps in Programming

Different programming languages handle Unix timestamps in distinct ways. Here is a quick reference:

// JavaScript — returns milliseconds
Date.now()                          // e.g. 1704067200000
Math.floor(Date.now() / 1000)       // convert to seconds

# Python
import time
time.time()                          # float seconds, e.g. 1704067200.0
import calendar
calendar.timegm((2024,1,1,0,0,0,0,0,0)) # → 1704067200

// Java
System.currentTimeMillis() / 1000

# Go
time.Now().Unix()

# Unix command line
date +%s                                # current timestamp
date -d @1704067200                     # convert back

Important Notes

JavaScript returns milliseconds — always divide by 1000 to get seconds.
Python floats — time.time() returns a float with sub-second precision. Use int() to truncate.
Databases — PostgreSQL, MySQL, and SQLite all support storing and querying Unix timestamps natively.
Time zones — Unix timestamps are always in UTC. You must convert to a time zone when displaying to users.

Unix Timestamp vs Other Time Formats

Unix timestamps are not the only way to represent time. Here is how they compare to other common formats:

Format	Example	Pros	Cons
Unix Timestamp	`1704067200`	Compact, timezone-neutral, sortable	Not human-readable
ISO 8601	`2024-01-01T00:00:00Z`	Human-readable, widely standardized	Longer string, requires parsing
RFC 2822	`Mon, 01 Jan 2024 00:00:00 GMT`	Email-friendly, human-readable	Verbose, locale-dependent
Julian Date	`2460310.5`	Continuous, used in astronomy	Unfamiliar to most developers
Windows FileTime	`133507680000000000`	100-nanosecond precision	Platform-specific, huge numbers

For most web APIs and databases, ISO 8601 and Unix timestamps are the two dominant formats. Many systems accept both, converting between them as needed.

Frequently Asked Questions

What is the Unix epoch?

The Unix epoch is midnight UTC on January 1, 1970. It serves as the zero reference point for all Unix timestamps. Every timestamp is simply the number of seconds elapsed since that moment. The date was chosen by Unix creators Ken Thompson and Dennis Ritchie and has been the standard for over 50 years.

What is the current Unix timestamp?

The current Unix timestamp is the real-time count of seconds since the epoch. It changes every second. You can retrieve it in JavaScript with Math.floor(Date.now() / 1000), in Python with int(time.time()), or on the command line with date +%s.

Does Unix time count leap seconds?

No. Unix timestamps treat every day as exactly 86,400 seconds. Leap seconds are ignored, which means Unix time can drift slightly from Coordinated Universal Time (UTC) over very long periods. This simplification avoids the complexity of handling irregular second insertions in software systems.

What is the maximum Unix timestamp?

On a 32-bit signed integer, the maximum Unix timestamp is 2,147,483,647, which corresponds to January 19, 2038 at 03:14:07 UTC. On a 64-bit signed integer, the maximum is 9,223,372,036,854,775,807, which will not overflow for approximately 292 billion years. Modern systems overwhelmingly use 64-bit representations.

Tools: Epoch Converter