Unix Timestamp Converter

About Unix time

The Unix epoch

A Unix timestamp counts the time elapsed since the Unix epoch, 1970-01-01T00:00:00Z. Unix time treats every day as exactly 86,400 seconds, so leap seconds are not counted. A timestamp identifies an instant and has no time zone; the zone only matters when it is turned into a wall-clock date.

Common formats

How this converter works

Values are held as exact integers (BigInt), so a 19-digit nanosecond timestamp is never rounded through a floating-point number. Decimals are accepted up to the unit’s limit, such as 1700000000.123456789 seconds. Negative timestamps are dates before 1970: −1 millisecond is 23:59:59.999 on December 31, 1969. The supported range is the years 1 to 9999.

Auto-detect and ambiguity

Auto picks the unit from the size of the number: below 10¹¹ it is seconds, below 10¹⁴ milliseconds, below 10¹⁷ microseconds, otherwise nanoseconds. A value in the last decade below a boundary, such as 50000000000, is a plausible date in two units (the year 3554 as seconds, 1971 as milliseconds). The tool then says so and shows the other reading; choose the unit yourself to settle it.

Precision of the timestamp and of the date

The date is shown with as many fractional digits as the timestamp has: three for milliseconds, six for microseconds, nine for nanoseconds. That is the precision of the number, not a claim about the clock that produced it.

The Year 2038 problem

Systems that store Unix time in a signed 32-bit integer run out of range after 2,147,483,647 seconds, which is 2038-01-19T03:14:07Z. One second later the value wraps to −2,147,483,648, which reads as 1901-12-13T20:45:52Z. Modern systems use 64-bit time, which lasts for hundreds of billions of years, but 32-bit fields still exist in older software, embedded devices and some file and database formats.

Code examples

Each snippet was run and printed the commented result.

new Date(1700000000 * 1000).toISOString()
// "2023-11-14T22:13:20.000Z"
Math.floor(Date.parse("2023-11-14T22:13:20Z") / 1000)
// 1700000000
Math.floor(Date.now() / 1000)  // now

from datetime import datetime, timezone
datetime.fromtimestamp(1700000000, tz=timezone.utc).isoformat()
# '2023-11-14T22:13:20+00:00'
int(datetime(2023, 11, 14, 22, 13, 20,
             tzinfo=timezone.utc).timestamp())
# 1700000000

t := time.Unix(1700000000, 0).UTC()
t.Format(time.RFC3339) // 2023-11-14T22:13:20Z
t.Unix()               // 1700000000
time.Now().Unix()      // now

echo gmdate("c", 1700000000);
// 2023-11-14T22:13:20+00:00
echo strtotime("2023-11-14T22:13:20Z");
// 1700000000
echo time();  // now

SELECT datetime(1700000000, 'unixepoch');
-- 2023-11-14 22:13:20
SELECT CAST(strftime('%s', '2023-11-14 22:13:20') AS INTEGER);
-- 1700000000

SET time_zone = '+00:00';
SELECT FROM_UNIXTIME(1700000000);
-- 2023-11-14 22:13:20
SELECT UNIX_TIMESTAMP('2023-11-14 22:13:20');
-- 1700000000