Unix Time Converter
Enter a Unix timestamp to get the corresponding UTC and local date, ISO 8601 string, day of week, ISO week number, and a breakdown of how much time has passed since the epoch. Or switch to "Date to timestamp" mode and pick a date to get the epoch value in seconds, milliseconds, microseconds, or nanoseconds. Results update instantly as you type.
What is a Unix timestamp?
A Unix timestamp (also called epoch time, POSIX time, or Unix time) is the number of seconds that have elapsed since 00:00:00 UTC on 1 January 1970, not counting leap seconds. It is a single integer, always in UTC, so it identifies the same moment anywhere in the world regardless of timezone. Computers store it efficiently as a plain integer, making it ideal for databases, log files, APIs, file systems, and any situation where you need to compare or sort times across machines and timezones.
Seconds, milliseconds, microseconds and nanoseconds
The original Unix spec counted whole seconds, giving a 10-digit number for dates after 2001. Modern systems often need sub-second precision. JavaScript and many web APIs use milliseconds (13 digits), giving 1,000 timestamps per second. Databases and tracing systems may use microseconds (16 digits, 1,000,000 per second) or nanoseconds (19 digits, 1,000,000,000 per second). To convert between units, multiply or divide by the appropriate power of 10: divide milliseconds by 1,000 to get seconds, divide microseconds by 1,000,000, and divide nanoseconds by 1,000,000,000. A quick rule of thumb: count the digits - 10 digits means seconds, 13 means milliseconds, 16 means microseconds.
The Year 2038 problem
Many older systems store the Unix timestamp in a signed 32-bit integer, which can hold values from -2,147,483,648 to 2,147,483,647. That upper limit corresponds to 03:14:07 UTC on 19 January 2038. One second later the counter rolls over to a large negative number, which most software would interpret as a date in December 1901. This is the Unix equivalent of the Y2K problem. Modern 64-bit systems and languages are not affected because they use 64-bit integers, which can represent dates hundreds of billions of years into the future. Legacy embedded systems, older databases, and 32-bit file systems remain at risk until upgraded.
Converting between timestamps and dates
To convert a Unix timestamp to a human-readable date, add the timestamp (in seconds) to the epoch (1 January 1970 00:00:00 UTC) using any date library or this calculator. To go the other way, subtract the epoch from your target date - most programming languages expose this as Date.now() / 1000 in JavaScript, time.time() in Python, or System.currentTimeMillis() / 1000L in Java. The calculator here handles both directions, supports all four precision levels, and shows the ISO 8601 string, day of week, ISO week number, and a days-hours-minutes-seconds breakdown for every result.
Common Unix timestamp reference points
| Event | Unix timestamp (s) | UTC date |
|---|---|---|
| Unix epoch start | 0 | 1970-01-01 00:00:00 |
| Start of 1990 | 631152000 | 1990-01-01 00:00:00 |
| Y2K (start of 2000) | 946684800 | 2000-01-01 00:00:00 |
| Start of 2010 | 1262304000 | 2010-01-01 00:00:00 |
| Start of 2020 | 1577836800 | 2020-01-01 00:00:00 |
| Start of 2024 | 1704067200 | 2024-01-01 00:00:00 |
| Y2038 overflow limit | 2147483647 | 2038-01-19 03:14:07 |
Notable epoch values in seconds for quick orientation.
Frequently asked questions
What is the current Unix timestamp?
The current Unix timestamp changes every second. To get it right now, switch the calculator to "Timestamp to date" mode and type the number you see in your system clock, or use a command line: run "date +%s" on Linux or macOS, or "(Get-Date -UFormat %s)" in PowerShell. In JavaScript, "Math.floor(Date.now() / 1000)" gives the current epoch in seconds.
How do I tell if a timestamp is in seconds or milliseconds?
Count the digits. A Unix timestamp in seconds has 10 digits for any date after 9 September 2001 (epoch 1,000,000,000). A 13-digit value is almost certainly milliseconds, 16 digits is microseconds, and 19 digits is nanoseconds. For older dates or negative timestamps (before 1970) the digit count shifts, so also check whether dividing by 1,000 gives a plausible year.
What is the Unix epoch and why does it start in 1970?
The Unix epoch is the reference point 00:00:00 UTC on 1 January 1970. Unix was developed at Bell Labs in the late 1960s, and 1970 was chosen as a round starting date close to when the operating system was being designed. The exact origin was also practical: a 32-bit integer counting from 1970 could represent dates up to 2038, which seemed far enough in the future at the time.
What is ISO 8601 and how does it relate to Unix time?
ISO 8601 is an international standard for representing dates and times as strings, for example "2024-11-14T22:13:20Z" (the trailing Z means UTC). It is the format used in JSON APIs, HTML datetime attributes, and most modern databases. A Unix timestamp and an ISO 8601 string represent the same moment - they are just two different notations. This calculator shows the ISO 8601 equivalent of any timestamp so you can copy it directly into an API request or database query.
What happens after the Year 2038 overflow?
On systems that store Unix time in a signed 32-bit integer, the counter will reach its maximum value of 2,147,483,647 at 03:14:07 UTC on 19 January 2038 and then wrap around to -2,147,483,648, which those systems interpret as 13 December 1901. The practical impact depends entirely on the software: some will crash, some will misinterpret dates, and some will be fine because they already use 64-bit storage. Modern 64-bit systems, current Linux kernels, and most programming languages are not affected.
Do Unix timestamps count leap seconds?
No. The POSIX standard defines Unix time as if every day has exactly 86,400 seconds. Leap seconds are silently dropped, so each day containing a leap second actually has 86,401 real seconds but only 86,400 Unix seconds. In practice this means Unix time drifts by one second per leap second compared to true atomic time (TAI). For most applications this does not matter, but high-precision timekeeping systems use UTC with leap second tables or GPS time instead.