Unix Timestamps Explained: Seconds, Milliseconds and the Year 2038

You can check any of these in our Unix timestamp converter.

The classic Unix timestamp counts seconds, but many systems count milliseconds instead. JavaScript's Date.now() returns milliseconds, while most databases and server logs use seconds. The easiest way to tell them apart is to count digits. A current timestamp in seconds has 10 digits (for example 1700000000), and one in milliseconds has 13 (1700000000000).

If you feed a millisecond value to something that expects seconds, you get a date tens of thousands of years in the future. If you do the reverse, you get a date in January 1970. Both are a quick sign that the unit is wrong.

A Unix timestamp has no time zone. It always refers to one instant, and the same number is the same moment everywhere. The time zone only matters when you display it: 1700000000 is 22:13:20 in UTC, 17:13:20 in New York and 09:13:20 the next day in Sydney (using the offsets in force on 14 November 2023, when Sydney was on daylight saving time). Store and compare timestamps in UTC, and convert to local time only for people to read.

• Excel or Google Sheets: =A1/86400+DATE(1970,1,1), then format the cell as date and time. For milliseconds, divide by 86400000 instead. The result is in UTC.
• JavaScript: new Date(ts * 1000).toISOString() for seconds, or new Date(ts).toISOString() for milliseconds.
• Python: datetime.fromtimestamp(ts, tz=timezone.utc) with from datetime import datetime, timezone.
• PostgreSQL: to_timestamp(ts).
• MySQL: FROM_UNIXTIME(ts), which uses the session time zone.
• Linux shell: date -u -d @1700000000. On macOS use date -u -r 1700000000.

Going the other way, Python's int(datetime.now(timezone.utc).timestamp()) and JavaScript's Math.floor(Date.now() / 1000) both give the current time in seconds.

A negative timestamp is a moment before 1970: -86400 is 31 December 1969. Most modern languages handle these, though some older systems do not.

Unix time also ignores leap seconds. Every day is treated as exactly 86,400 seconds long, so the count does not include the occasional extra second that UTC adds. For most applications this makes no difference, but it means Unix time is not an exact count of elapsed physical seconds.

Some older systems store the timestamp in a signed 32-bit integer, whose largest value is 2147483647. That number is 03:14:07 UTC on 19 January 2038. One second later, the value overflows and wraps to a large negative number, which would read as December 1901. Modern systems use 64-bit integers, which will not overflow for about 292 billion years, so the risk is mostly in embedded devices, old databases and legacy file formats. If you maintain such systems, check where timestamps are stored and what type the column or field uses.

The exp, nbf and iat claims in a JSON Web Token are Unix timestamps in seconds. If a login keeps failing, converting exp to a date is a fast way to see whether the token has expired. Our guide on how to read a JWT walks through this.