Unix Timestamp Converter

How to Use the Unix Timestamp Converter

1. Pick a mode. "Timestamp to Date" takes a number and returns a human-readable date; "Date to Timestamp" takes a date/time and returns an integer.
2. Paste your timestamp (seconds or milliseconds). The component auto-detects precision by digit count: 10 digits is parsed as seconds, 13 digits as milliseconds. Click Convert to render local time, UTC, ISO 8601, and a relative-time label.
3. Or pick a date in "Date to Timestamp" mode to see the equivalent Unix seconds and milliseconds integers. Each field has a copy button.
4. Read the live counter at the top - it ticks every second so you always have the current epoch value one click away.

What Unix Time Actually Is (And Is Not)

A Unix timestamp is the number of seconds that have elapsed since 1970-01-01T00:00:00Z, ignoring leap seconds. "Ignoring leap seconds" is the single most important and most misunderstood detail. POSIX defines Unix time as (year - 1970) * 365.25 * 86400 plus day-of-year and second-of-day, with no correction for the ~27 leap seconds that UTC has absorbed since 1972. That means Unix time sometimes pauses (e.g., 23:59:60 becomes 23:59:59 a second time) or lurches forward - the exact strategy depends on the operating system's time sync daemon. Google's "leap smear" spreads the anomaly over 24 hours so nothing ever repeats. The conversion in this page reads Date.getTime(), which is the browser's already-smeared view, so you never see a 61-second minute. Parsing a timestamp is new Date(seconds * 1000); going the other way is Math.floor(date.getTime() / 1000).

When You Reach For Epoch Conversion

• Debugging a log line with a raw epoch timestamp ("why did 1699987200 trigger an alert?") and wanting to know what wall-clock time that was.
• Generating a cookie Expires value, a JWT iat/exp claim, or an OAuth2 token expiry - all of which are Unix seconds.
• Populating a database seed file with historical test data in BIGINT millisecond columns.
• Reading a photo EXIF DateTimeOriginal or a filesystem mtime and translating it to a meeting-friendly date.
• Comparing two API responses that disagree on whether their timestamp is seconds, milliseconds, or microseconds.
• Calculating countdowns based on API-returned deadlines in raw seconds since epoch.

Pitfalls Every Developer Eventually Hits

• Seconds vs. milliseconds. Multiplying a ms timestamp by 1000 yields the year 52,000-something; dividing a seconds timestamp by 1000 yields 1970. The difference is always a factor of 1000 and is always silently wrong when confused. Digit-count detection (10 vs. 13) is the usual heuristic.
• Year 2038. A signed 32-bit integer overflows at 2147483647 = 2038-01-19T03:14:07Z. Any system still storing Unix time in int32 will wrap to December 1901 on that second. 64-bit int64 systems push the overflow to year 292,277,026,596 - well past human concern. Embedded devices, old C, and some legacy file formats are the realistic risks; all mainstream languages long since moved to 64-bit time.
• Year 2106. Unsigned 32-bit overflows at 2106-02-07T06:28:15Z. Some older systems used uint32 specifically to push past 2038; they have their own cliff.
• Leap seconds. Unix time pretends they do not exist. The IERS added 27 of them between 1972 and 2017 (none since). The General Conference on Weights and Measures voted in 2022 to eliminate leap seconds by 2035. Until then, precise time-interval math across decades can be off by ±27 seconds.
• Negative timestamps. -86400 is 1969-12-31. Perfectly valid; some early database drivers choked on them. Modern languages handle negatives fine.
• Date.now() vs. performance.now(). The former is wall-clock milliseconds-since-epoch and jumps when the system clock is adjusted (NTP, DST, manual change). The latter is a monotonic high-resolution timer that never jumps but has no epoch reference. Use Date.now() for timestamps; use performance.now() for interval timing.

Epoch Across Systems And Specs

Unix time was introduced with the first edition of Unix in 1971; POSIX formalised it (IEEE Std 1003.1). Java's System.currentTimeMillis() shares the epoch, and JavaScript's Date inherits from Java. Other epochs exist: Windows FILETIME counts 100-ns intervals since 1601-01-01; Cocoa's NSDate uses 2001-01-01 UTC; Excel's serial date counts days since 1900-01-00 with a Lotus 1-2-3 compatibility bug that treats 1900 as a leap year (day 60 is "1900-02-29," which did not exist). RFC 3339 and ISO 8601 define the human-readable form that toISOString() emits. NTP daemons discipline local Unix time against UTC from pool.ntp.org or PTP sources.

Epoch Tools Compared

Command line: date -r 1700000000 on BSD/macOS or date -d @1700000000 on GNU/Linux - fast, but you have to remember which flag each flavour wants. Python: datetime.fromtimestamp(1700000000, tz=timezone.utc) - verbose but correct. PostgreSQL: to_timestamp(1700000000). epochconverter.com is the incumbent browser tool and has been around since the late 2000s; it supports several more esoteric epoch formats (Apple Mach absolute, Windows FILETIME hex) that we omit for focus. DevTools console: new Date(1700000000 * 1000).toISOString() is one line. This page wins for a visual side-by-side of local, UTC, ISO, and relative at once, with copy buttons and a live counter, without switching contexts away from your browser. For bulk or script-level use, the shell command or jq's todate/fromdate are unbeatable.