Unix Timestamp Converter

Unix time, explained: seconds since 1970

A Unix timestamp is a single integer: the number of seconds since the "epoch", 00:00:00 UTC on 1 January 1970. Because it carries no timezone and no formatting, it is unambiguous — two systems anywhere in the world agree on exactly which instant a given timestamp refers to. That is why it is the default way to store and transmit time in databases, log files, JWT claims, HTTP headers and most APIs.

The main source of confusion is scale. Classic Unix tooling and most backend languages count whole seconds, so a current timestamp is a 10-digit number. JavaScript (Date.now()), Java (System.currentTimeMillis()) and many browser APIs count milliseconds, giving 13 digits. Some systems go further to microseconds or nanoseconds. This converter assumes values with 13 or more digits are milliseconds and shorter values are seconds, and lets you override that guess.

Converting to a human date always involves a timezone. The same timestamp is "2023-11-14T22:13:20Z" in UTC and, say, "2:13 PM PST" on the US west coast — one instant, two labels. The ISO 8601 output here ends in "Z" to make the UTC basis explicit; the "Local" line applies your browser’s current timezone and daylight-saving offset.

Unix time deliberately ignores leap seconds: every day is treated as exactly 86,400 seconds. This keeps the arithmetic reversible at the cost of being a few seconds out of step with astronomical time. For almost all software that is the right trade-off. The historical "year 2038 problem" affects only systems that store the value in a signed 32-bit integer; 64-bit storage pushes the overflow far beyond any practical horizon.

Everything on this page runs locally through the browser’s built-in Date and Intl APIs, so you can convert timestamps offline and nothing you enter is sent anywhere.

timestamp (seconds) → date:  new Date(ts * 1000)
timestamp (milliseconds) → date:  new Date(ts)
date → timestamp (seconds):  Math.floor(date.getTime() / 1000)
ISO 8601 UTC:  date.toISOString()  // e.g. 2023-11-14T22:13:20.000Z

Worked examples

0             → 1970-01-01T00:00:00Z  (the epoch)
1700000000    → 2023-11-14T22:13:20Z
1700000000000 → the same instant, in milliseconds
2147483647    → 2038-01-19T03:14:07Z  (largest signed 32-bit value)
-86400        → 1969-12-31T00:00:00Z  (negative = before 1970)

In auto mode a value with 13 or more digits is read as milliseconds, anything shorter as seconds; switch the unit explicitly for microsecond or nanosecond timestamps, which some databases and tracing tools use, after dividing them down to milliseconds.

Getting the current timestamp in code

JavaScript   Math.floor(Date.now() / 1000)
Python       int(time.time())
Go           time.Now().Unix()
Java         Instant.now().getEpochSecond()
PostgreSQL   SELECT extract(epoch FROM now());
Shell        date +%s

Storing and comparing times

• Store instants as UTC timestamps or ISO 8601 with an offset, and convert to local time only for display.
• Do not store “local time” without its zone — 09:00 is ambiguous on its own, and repeats once a year at the end of daylight saving.
• Use 64-bit integers for timestamps in new schemas to avoid the 2038 overflow.