Unix Timestamp Converter

What is a Unix timestamp?

A Unix timestamp is the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC, ignoring leap seconds. Because it is a single integer in a fixed reference frame, it is the format systems use to store and compare instants without arguing about time zones or calendar formats.

The everyday difficulty is that the same instant appears as 1700000000 in one system, 1700000000000 in another, and 1700000000000000 in a third — seconds, milliseconds, and microseconds all called "a timestamp". This converter reads the magnitude to pick a unit, tells you which one it picked, and lets you override it, then shows the instant as ISO 8601, as UTC, and in your own time zone.

Unix epoch time is the number of seconds that have elapsed since 00:00:00 UTC on 1 January 1970, minus leap seconds.

POSIX.1-2024, Base Definitions §4.19

Features

Tells seconds from milliseconds: The unit is inferred from the number of digits and shown explicitly, so a value that was a thousand times too large stops silently becoming a date in the year 55000.
Both directions: Paste an epoch number to get a date, or paste a date — ISO 8601, RFC 1123, or anything your browser parses — to get the epoch value back in seconds and milliseconds.
Your time zone and UTC side by side: Storage and logs are almost always UTC while the bug report is in local time. Both are shown at once, with the resolved time-zone name.
A live current timestamp: The current epoch second is displayed and updated every second, for when the question is simply "what is the timestamp right now".

How to use

1
Paste the value
Enter a Unix timestamp in seconds, milliseconds, or microseconds — or a date string such as 2026-09-05T12:00:00Z.
2
Check the unit
Leave the unit on Auto to have it inferred from the magnitude, or pick one explicitly when you already know it.
3
Read the result
The instant is shown as ISO 8601 in UTC, as a UTC string, in your own time zone, and as epoch seconds and milliseconds.

Frequently asked questions

Is a Unix timestamp in seconds or milliseconds?

The original definition is seconds, and that is what most Unix APIs, JWT claims, and database epoch columns use. JavaScript's Date.now() returns milliseconds, and many logging systems use microseconds. A present-day value in seconds has ten digits, milliseconds has thirteen, and microseconds has sixteen — which is how this tool infers the unit.

What is the current Unix timestamp?

It is displayed live on this page, in seconds, and updates every second. It is the count of seconds since 1970-01-01 00:00:00 UTC.

Does a Unix timestamp have a time zone?

No — that is the point of it. A timestamp names an instant, not a wall-clock reading, so it is the same integer everywhere on earth. A time zone is applied only when you format it for a person to read, which is why this tool shows UTC and your local rendering of the very same number.

What is the year 2038 problem?

Systems that store the timestamp in a signed 32-bit integer overflow on 2038-01-19T03:14:07Z, wrapping around to 1901. Any system still using a 32-bit time_t will need 64-bit storage before then. This converter uses JavaScript numbers and is not affected.

Why does my timestamp convert to 1970?

A value that is small — often zero, or a millisecond value being read as seconds after an accidental division — lands near the epoch itself. A date of 1970-01-01 is almost always an uninitialised or missing value rather than a real one.

Do leap seconds affect this?

Unix time deliberately ignores them: it assumes every day has exactly 86,400 seconds. A leap second is absorbed by repeating a value rather than adding one, so timestamp arithmetic stays simple at the cost of not being a true count of elapsed SI seconds.

If you hit this

Specifications this follows

POSIX.1-2024 — Seconds Since the Epoch — Defines the epoch and the assumption that every day has exactly 86,400 seconds.
RFC 3339 — Date and Time on the Internet: Timestamps — The ISO 8601 profile used for the formatted output on this page.
MDN — Date.now() — Returns milliseconds, which is where most seconds-versus-milliseconds confusion begins.