Convert Unix timestamps to dates and back
If you have ever seen a number like 1700000000 in a log file, a database or an API response and wondered what date it represents, this tool is for you. This free Unix timestamp converter translates epoch time into human-readable dates and turns any date back into a timestamp. It shows a live current timestamp, supports both seconds and milliseconds, and displays results in UTC, your local time and ISO 8601 format — all with one-click copy, and all running privately in your browser.
What a Unix timestamp is
A Unix timestamp, also called epoch time, is simply the number of seconds that have elapsed since midnight UTC on 1 January 1970 — a moment known as the "Unix epoch." That single growing integer represents an exact point in time, anywhere in the world, without reference to timezones or date formats. Because it is just a number, it is compact to store, trivial to compare, and unambiguous across systems. This is why it has become the default way computers record when something happened.
Why developers rely on epoch time
Storing time as one integer neatly sidesteps a whole category of headaches: timezones, daylight saving changes, and the endless variations in how dates are written around the world. Two servers on opposite sides of the planet will agree on the exact same Unix timestamp for a given instant. That makes epoch time ideal for log entries, tokens with an expiry time, cache keys, database records, event ordering and anything that needs a reliable, sortable moment. When you need to display that moment to a human, you convert it back into a readable date — which is exactly what this tool does.
Seconds versus milliseconds
One of the most common bugs when working with timestamps is mixing up seconds and milliseconds. Many languages — including PHP, Python and Ruby — work in seconds by default, while JavaScript works in milliseconds. A timestamp that is off by a factor of 1,000 will land in completely the wrong era: interpret a seconds value as milliseconds and a date in 2023 suddenly appears in 1970. To spare you that trap, this converter automatically detects the unit. Values with 13 or more digits are treated as milliseconds, and shorter values as seconds, so you can paste either without a second thought.
UTC, local time and ISO 8601
For every timestamp you enter, the tool shows three views of the same instant. UTC is Coordinated Universal Time, the global reference with no timezone offset. Local time is that same moment shown in your own computer's timezone, which is what a human in your region would see on a clock. ISO 8601 is a standardised string such as 2023-11-14T22:13:20.000Z that sorts correctly as plain text and is the format most APIs and databases prefer. Seeing all three at once makes it easy to confirm you are reasoning about the right moment.
How to use the converter
To go from a timestamp to a date, paste the number and read off the UTC, local and ISO versions. To go the other way, pick a date and time and the tool shows you the matching timestamp in both seconds and milliseconds, ready to copy. A live counter at the top ticks up every second so you always have the current epoch time to hand. Whether you are debugging an API, setting a token expiry, or just decoding a mysterious number in a log, the answer is immediate — and because it works locally, nothing you enter ever leaves your browser.
The year 2038 problem
Unix time has one famous quirk worth knowing about. Many older systems store timestamps as a signed 32-bit integer, which can only count up to 2,147,483,647 seconds after the 1970 epoch. That ceiling is reached at 03:14:07 UTC on 19 January 2038, after which the number overflows and wraps around to a large negative value — meaning affected systems would suddenly think the date is back in 1901. Nicknamed the "Year 2038 problem" or the epochalypse, it is the modern equivalent of the Year 2000 bug. The fix is straightforward: use a 64-bit integer instead, which pushes the limit billions of years into the future, and most current systems, languages and databases already do exactly that. Still, the issue lingers in legacy hardware, embedded devices and old file formats that are expensive to update. It is a useful reminder that the tidy simplicity of storing time as a single number depends entirely on giving that number enough room to grow. When you work with timestamps today, sticking to 64-bit values keeps you safely clear of the problem.
Frequently asked questions
What is a Unix timestamp?
It is the number of seconds since 00:00:00 UTC on 1 January 1970. This compact, timezone-independent number is how computers commonly store a moment in time.
Does it handle milliseconds?
Yes. The tool auto-detects the unit: values with 13 or more digits are treated as milliseconds, and shorter values as seconds, so timestamps from any language work.
Why does local time differ from UTC?
The same instant is shown in Coordinated Universal Time and in your computer's local timezone. The difference is your timezone offset; the underlying moment is identical.
What is ISO 8601?
ISO 8601 is an international standard for writing dates and times, such as 2023-11-14T22:13:20.000Z. It sorts correctly as text and is widely used in APIs.