What is a Unix Timestamp Converter?
A Unix timestamp is the number of seconds that have passed since 00:00:00 UTC on 1 January 1970, a moment called the epoch. This tool converts one into a readable date in UTC, in your local time zone and in ISO 8601, and converts a date back into seconds and milliseconds.
The format exists because a single integer is unambiguous. A date written `03/04/2026` means March in one country and April in another, and any written date has to carry a time zone to be exact. An epoch value carries neither problem: it is the same number everywhere on Earth at the same instant, which is why databases, tokens and log lines store it.
Unix time ignores leap seconds. Every day is treated as exactly 86,400 seconds, so the count drifts from astronomical time by a second or so every few years; UTC's own leap-second corrections absorb the difference. For software that is the right trade — monotonic arithmetic matters more than matching the rotation of the Earth.
How to convert a Unix timestamp
- Paste a timestamp into the first box. Ten digits is read as seconds and eleven or more as milliseconds, so both common formats work.
- Read the five results: UTC, your local time, ISO 8601, and the value in seconds and milliseconds.
- Use Copy on the line you need — ISO 8601 for a log, seconds for an API field.
- For the other direction, pick a date and time in the second box. It is read as your device's local time zone.
- Press the button under the live clock to drop the current timestamp into the box and see how it resolves.
Unix Timestamp Converter limits and rules
| Item | Limit |
|---|---|
| Epoch | 1970-01-01T00:00:00Z, seconds or milliseconds |
| Digit heuristic | 10 digits or fewer = seconds; 11 or more = milliseconds |
| Negative values | Supported — they describe dates before 1970 |
| Leap seconds | Ignored; every day counts as 86,400 seconds |
| Date input zone | Your device's local time zone, not UTC |
| Output formats | RFC 1123 (UTC), local string, ISO 8601, seconds, milliseconds |
| Range | About ±8.64 × 10¹⁵ ms, the JavaScript `Date` limit |
| 32-bit overflow | Values above 2,147,483,647 overflow signed 32-bit storage — 2038-01-19 |
When to use it
- Reading a `created_at` field from an API that returns epoch seconds.
- Writing a token expiry: take now, add 3,600 seconds, store the integer.
- Checking whether a cached value is older than its TTL by comparing two timestamps.
- Turning a log line's timestamp into local time to line it up with a support ticket.
- Confirming the year-2038 boundary before choosing an integer width for a database column.
Is it private?
Everything runs inside your browser. Your text and files are never uploaded, never stored and never seen by anyone else — including me. You can use the tool with the network tab open and watch no request leave the page. Closing the tab erases the input.
Frequently asked questions
Count the digits. Ten or fewer is seconds — the format most APIs and databases use. Thirteen is milliseconds, which is what JavaScript's `Date.now()` returns. This tool decides by length, so a value like `1700000000000` is treated as milliseconds and `1700000000` as seconds.
Because of time zones. The UTC line is exact; the local line uses your device's zone and daylight-saving rules. If a server wrote a local time and you read it as UTC, the difference is your offset. ISO 8601 with a trailing `Z` is always UTC.
A signed 32-bit integer can hold at most 2,147,483,647, which as a Unix timestamp is 03:14:07 UTC on 19 January 2038. Systems that store time that way will overflow on that date. Modern databases use 64-bit columns, which push the limit billions of years out, but embedded and legacy code still needs auditing.
No. It treats every day as exactly 86,400 seconds, so the count is not a precise measure of elapsed SI seconds across a leap-second insertion. For display and scheduling that is fine; for astronomy it is not. The alternative — TAI or a leap-second-aware scale — is rarely what an application actually wants.
As a 64-bit integer of seconds or milliseconds, or as a native `timestamptz` column. Both are unambiguous; what to avoid is a string without a zone. If you use an integer, document the unit in the column name — `created_at_ms` is clearer than a comment nobody reads.
No. The conversion uses the JavaScript `Date` object in the page, and the live clock is a one-second interval in your browser. No request is made, so the tool works offline and your timestamps stay local.
Related tools
Written and maintained by Md. Nur Hossain Repon.