# Unix time converter

> Type a Unix timestamp — seconds, milliseconds, microseconds, or nanoseconds, detected automatically — or an ISO-8601 date, and read it back in every common format. All in your browser.

- Tool: https://ronutz.com/en/tools/epoch
- Family: Encoding & data

---

## What it does

Enter a Unix timestamp or an ISO-8601 date and read the same instant back in every common form. When you enter a number, the tool auto-detects its unit (seconds, milliseconds, microseconds, or nanoseconds) from its magnitude, so you can paste a value from almost any system without saying which unit it is. It then renders the instant as a UTC calendar breakdown, an ISO-8601 string, an RFC 3339 timestamp, the HTTP date format, and the timestamp itself in all four units. Everything is computed in your browser.

## What Unix time means

Unix time, defined by POSIX, is the number of seconds elapsed since the epoch (1970-01-01 00:00:00 UTC), not counting leap seconds. Different systems store it at different resolutions: classic Unix and most APIs use seconds; JavaScript and many databases use milliseconds; some tracing and kernel interfaces use microseconds or nanoseconds. Because those magnitudes are roughly a thousand apart, the unit can be inferred from how many digits the number has, which is what the auto-detection does.

## The formats it produces

- **UTC calendar breakdown**, the year, month, day, and time of day in UTC.
- **ISO 8601 and RFC 3339**, the internet timestamp format, for example `2026-07-01T20:00:00Z`.
- **HTTP date**, the IMF-fixdate form used in HTTP headers (RFC 9110, section 5.6.7), for example `Wed, 01 Jul 2026 20:00:00 GMT`.
- **All four units**, the same instant expressed as seconds, milliseconds, microseconds, and nanoseconds.

## Range and determinism

Dates are handled within the range a JavaScript date value can represent, roughly plus or minus 273,000 years around the epoch (a limit of 8.64 x 10^15 milliseconds on either side). The conversion is a pure function of the input value and never reads the current clock, so a given timestamp always renders the same way. A "relative to now" convenience necessarily needs the wall clock, so it lives in the tool's interface rather than in this deterministic core.

## Using it

Enter a Unix timestamp such as `1751400000` (a ten-digit value, so it is read as seconds) or `1751400000000` (thirteen digits, read as milliseconds), or an ISO-8601 date such as `2026-07-01T20:00:00Z`, and read every equivalent form at once.

## Standards and references

- [POSIX.1-2017 — Seconds Since the Epoch (IEEE Std 1003.1)](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_16) - definition of Unix time
- [RFC 3339 — Date and Time on the Internet: Timestamps](https://www.rfc-editor.org/rfc/rfc3339) - ISO 8601 profile, offsets
- [RFC 9110 §5.6.7 — HTTP-date format](https://www.rfc-editor.org/rfc/rfc9110#section-5.6.7) - HTTP/IMF-fixdate format
- [ECMAScript — Time Values and the Date range (±8.64e15 ms)](https://tc39.es/ecma262/#sec-time-values-and-time-range) - representable date range

## Related reading

- [ISO 8601, RFC 3339, and the HTTP Date](https://ronutz.com/en/learn/iso-8601-and-rfc-3339.md): Once a Unix timestamp is turned back into a human date, it gets written in one of a few standard text formats. ISO 8601 is the broad standard, RFC 3339 is its strict internet profile, and the HTTP date is the odd one out. Knowing the difference saves a lot of parsing grief.
- [Seconds, Milliseconds, Microseconds, Nanoseconds: Telling Epoch Units Apart](https://ronutz.com/en/learn/epoch-units-seconds-to-nanoseconds.md): The same instant can be written as 1700000000, 1700000000000, or larger, depending on whether the timestamp counts seconds, milliseconds, microseconds, or nanoseconds. Mixing them up is a classic bug. You can almost always tell which is which from the number's magnitude.
- [The Year 2038 Problem](https://ronutz.com/en/learn/the-year-2038-problem.md): A signed 32-bit integer can count seconds only up to 2147483647, which falls on 2038-01-19T03:14:07Z. One second later it overflows and wraps to a negative number, throwing affected systems back to 1901. It is Y2K's quieter successor, and the fix is a wider integer.
- [What Unix Time Actually Is](https://ronutz.com/en/learn/unix-time-explained.md): Unix time is a single integer: the number of seconds since 1970-01-01T00:00:00Z, the epoch. It is time-zone independent, compact, and sortable, which is why it underpins almost every system clock, log line, and API timestamp. Converting it to a calendar date is pure arithmetic.
- [Why Unix Time Ignores Leap Seconds](https://ronutz.com/en/learn/unix-time-and-leap-seconds.md): UTC occasionally inserts a leap second to stay aligned with the Earth's rotation, but Unix time pretends every day is exactly 86,400 seconds long. That deliberate simplification means a Unix timestamp is not a true count of elapsed seconds since the epoch — and it is the right trade-off for civil time.