Epoch & Unix Timestamp Converter

Every developer eventually stares at a number like 1786406400 and wonders what day that is. This epoch timestamp converter turns Unix time into a human date and back again, live in both directions, and it works out whether you pasted seconds, milliseconds or microseconds from the magnitude of the number, so you never have to count digits.

You get UTC, your local zone and ISO 8601 for every conversion, a live ticker of the current timestamp with one-click copy, and a batch mode for pasting a whole list at once. Everything is evaluated in your browser, so your log data never leaves your machine.

How to use

1. Paste a Unix timestamp into the timestamp field, in seconds, milliseconds or microseconds.
2. Read the human date instantly in UTC, your local time zone, and ISO 8601 format.
3. Or work the other way: pick a date and time and read the resulting timestamp.
4. Grab the current timestamp from the live ticker using the copy button.
5. For multiple values, switch to batch mode and paste one timestamp per line.
6. Copy any result field with a single click.

Why use our epoch & unix timestamp converter?

Automatic magnitude detection is the small feature that saves the most swearing. 1786406400 is seconds, 1786406400000 is milliseconds, 1786406400000000 is microseconds. Read milliseconds as seconds and your date lands tens of thousands of years in the future. Read seconds as milliseconds and it is still January 1970. I check the digits, pick the sensible interpretation, and tell you which one I picked so you can override it if your data really is that strange.

Showing UTC, local time and ISO 8601 together is deliberate, because those are the three answers you actually need. UTC is what servers and databases speak, local time is what the bug report means by yesterday afternoon, and ISO 8601 is what you paste into code, tickets and API calls. The conversion itself relies on JavaScript's Date object, documented exhaustively on MDN, so the output matches exactly what your own runtime would compute.

Batch mode came straight out of my own debugging sessions. Log excerpts rarely contain one timestamp, they contain forty. Paste the list, get every line converted in order, and suddenly the six-hour gap in the middle that explains the outage is staring back at you.

Nothing is uploaded, which matters more here than for most tools. Timestamps copied out of production logs tend to sit right next to user IDs and error messages, and pasting that into a random website that posts it to a server is exactly how confidential data leaks. This page does the math locally, and I never see any of it.

Who is this tool for?

Debugging is the daily driver. A support ticket says the error happened around 3pm, the log says 1786363200. Convert it, see both UTC and your local time, and you know whether you are looking at the right incident or a different one twelve hours out. Batch mode does the same for a whole stack of log lines at once.

Anyone writing API code hits this constantly: token expiry fields, cache TTLs, created_at columns stored as integers. Converting a date into a timestamp before writing a database query, or double-checking that the expiry you are about to set is next week rather than 1970, is a five-second job here.

Data people use it for spreadsheet exports where some system helpfully dumped an epoch column. Paste the column into batch mode, get readable dates back, and carry on with your life. If those timestamps arrived inside a token, my JWT decoder shows the iat and exp claims decoded, and the JSON formatter makes the surrounding payload readable first.

And because every result shows UTC next to local, it doubles as a quick answer when a colleague in another office asks when something actually happened. For the meeting-scheduling version of that problem, the time zone converter compares whole cities side by side.

Frequently asked questions