Seconds vs milliseconds vs nanoseconds: which unit is a timestamp in?

Unix time is a count from 1970-01-01T00:00:00Z. Count seconds and a current value has 10 digits: 1700000000. Count milliseconds and it has 13: 1700000000123. Microseconds give 16 digits and nanoseconds 19: 1700000000123456789. All four describe the same instant, 14 November 2023 at 22:13:20 UTC, plus a fraction that each unit holds more of.

The length of the integer is the quickest tell. A decimal point is the second clue: 1700000000.123 is seconds with a fraction, which is what Python's time.time() returns, while 1700000000123 with no point is milliseconds. The Unix timestamp converter reads the unit from the number of digits and names it above the result.

A signed 64-bit integer tops out at 9223372036854775807. Counting seconds, that is about 292 billion years. Counting nanoseconds, the same integer runs out on 2262-04-11T23:47:16Z, which is why Go's time.UnixNano and several databases document that date as their ceiling.

JavaScript has a tighter limit. Its numbers are 64-bit floats, exact only up to 2^53, which is 9007199254740991. Every millisecond timestamp fits, since the Date type itself stops at 8640000000000000. A microsecond count stays exact until the year 2255. A nanosecond count for any date after April 1970 is already past 2^53, so Number("1700000000123456789") rounds to the nearest double, which prints as 1700000000123456800. The last digits are gone before your code runs.

Seconds are the Unix default: the C time_t, the shell's date +%s, Python's time.time(), JWT exp claims and most REST APIs. Milliseconds are the JavaScript and Java default through Date.now() and System.currentTimeMillis(), and Kafka stamps every record in milliseconds. Microseconds appear in PostgreSQL, whose timestamp type keeps six fractional digits, and in Python's datetime, which also stops there. Nanoseconds are the Go default with time.UnixNano, the resolution of Linux's clock_gettime and of ext4 file timestamps, and the unit InfluxDB uses on the wire.

Prometheus is the odd one: it stores millisecond timestamps, but its query language returns time as seconds in a float. When two systems meet, check the unit before you check anything else.

Divide or multiply by 1,000 per step, and do it on integers. In JavaScript, use BigInt for anything finer than milliseconds: BigInt("1700000000123456789") / 1000000n is 1700000000123n, and the % operator keeps the 456789 you dropped. If the value arrives as a string, slice it instead of parsing it. The first 10 characters are the seconds and the first 13 are the milliseconds, with no arithmetic and no rounding. In Python, integers are unbounded, so 1700000000123456789 // 10**9 is safe. Go's time.Unix(sec, nsec) takes seconds and nanoseconds as two int64 values.

parsetime slices the string the same way. A 19-digit input is shown to the millisecond, and a note says the last six digits were dropped. For a 13-digit value, the milliseconds to date page shows the seconds form next to it.