Unix Time Converter
A Unix timestamp converter. Paste an epoch value (seconds or milliseconds — auto-detected) to get the human-readable date in both UTC and your local timezone, or pick a date to get the timestamp back. Shows the ISO 8601 string, relative time, and the current epoch ticking live. Runs entirely in your browser.
Timestamp → date
Reading as seconds (auto)
- UTC
- Tue, 14 Nov 2023 22:13:20 GMT
- Local
- Wednesday, November 15, 2023 at 3:43:20 AM GMT+5:30
- ISO 8601
- 2023-11-14T22:13:20.000Z
- Relative
- 2 years ago
Date → timestamp
- Epoch seconds
- 1699980180
- Epoch milliseconds
- 1699980180000
Computers agree on time by counting from one moment. That moment is the Unix epoch — 1970-01-01 00:00:00 UTC — and a timestamp is simply how many seconds have passed since then. Because it is a single integer with no timezone attached, it is unambiguous: two servers on opposite sides of the world stamp the same instant with the same number.
The everyday friction is units. Unix tools, Postgres and most system calls speak seconds (a ~10-digit number today); JavaScript, Java and many web APIs speak milliseconds (~13 digits). Feed one where the other is expected and you are off by a factor of 1000 — a date in 1970 or in the year 54,000. This converter reads the magnitude to guess the unit, and lets you force it, so that class of bug is obvious at a glance.
The other trap is display. The stored instant is timezone-free, but humans read local time, which is offset from UTC and shifts with daylight saving. The discipline that avoids pain: store and log in UTC (or raw epoch), convert to local only at the edge for a person to read. The tool shows both side by side so you never confuse the canonical instant with its local rendering.
How it works
- Auto-detects seconds vs milliseconds from the value’s magnitude.
- Renders UTC, local time, ISO 8601 and relative ("3 hours ago").
- Converts a picked date back to an epoch value.
- Shows the current epoch ticking live; all in-browser.
Frequently asked questions
What is a Unix timestamp?
A Unix timestamp (or epoch time) is the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC, not counting leap seconds. It is a single, timezone-free integer that uniquely identifies an instant, which is why systems store and exchange time this way and only convert to a human, timezone-aware format for display. 1700000000, for example, is 2023-11-14T22:13:20Z.
Seconds or milliseconds — how does the tool know?
By magnitude. A seconds timestamp for a current date is about 10 digits (1.7 billion); the same instant in milliseconds is about 13 digits (1.7 trillion). The converter auto-detects which you pasted from the number of digits and interprets it accordingly, while letting you override the unit. JavaScript, Java and many APIs use milliseconds; Unix tools, Postgres epoch and most Unix system calls use seconds — mixing them up is a classic 1000× bug.
Why show both UTC and local time?
The timestamp itself is an absolute instant with no timezone. UTC is the canonical, unambiguous rendering — the one to use in logs, APIs and when comparing across regions. Local time is what a human in your timezone actually experiences, offset from UTC and affected by daylight saving. Showing both prevents the common mistake of reading a UTC log line as if it were local, or vice versa.
What is the 2038 problem?
Systems that store the timestamp as a signed 32-bit integer can only count up to 2,147,483,647 seconds, which is reached on 2038-01-19. After that the counter overflows to a negative number and dates wrap to 1901. Modern systems use 64-bit timestamps, which push the limit hundreds of billions of years out, but legacy 32-bit code and data formats remain a real migration concern — the same shape of bug as Y2K.