Unix Timestamp Converter

Convert between Unix timestamps and human-readable dates. Live epoch clock auto-updates every second. Paste any 10-digit (seconds) or 13-digit (milliseconds) timestamp and convert to any timezone.

What is a Unix timestamp?

A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have elapsed since January 1, 1970 at 00:00:00 UTC, not counting leap seconds. It provides a single, unambiguous integer to represent any moment in time, independent of timezone or locale. Almost every programming language, database, and operating system supports Unix timestamps natively, making them the universal standard for time storage and exchange between systems.

Seconds vs milliseconds: auto-detecting the format

Most Unix timestamps are in seconds — a 10-digit number currently around 1.7 billion. JavaScript's Date.now() and many browser and web APIs return milliseconds instead, producing a 13-digit number. This converter automatically detects the unit from the magnitude of the input value.

  • 10-digit number (e.g. 1700000000) → seconds since the Unix epoch
  • 13-digit number (e.g. 1700000000000) → milliseconds since the Unix epoch
  • To convert seconds to milliseconds: multiply by 1000
  • To convert milliseconds to seconds: divide by 1000 (use Math.floor to get an integer)

Why does epoch time start on January 1, 1970?

The date was chosen by the original Unix developers in the early 1970s as a convenient reference point that predates modern computing. Since virtually all useful timestamps are positive integers, arithmetic and comparisons are straightforward. Although the choice was somewhat arbitrary, it became universal — every modern operating system, programming language, and protocol uses the same reference point.

How to convert epoch time to a human-readable date

Use the Epoch → Date tab above: paste any Unix timestamp, choose your timezone, and click Convert. The tool displays the result in ISO 8601 (with timezone offset), UTC string, a friendly long-form format, and a relative time indicator. You can also convert in the opposite direction using the Date → Epoch tab.

  • ISO 8601 — standard machine-readable format: 2023-11-15T06:13:20+00:00
  • UTC string — human-readable with day-of-week: Wed, 15 Nov 2023 06:13:20 GMT
  • Friendly — locale-style: Wednesday, November 15, 2023 at 6:13:20 AM UTC
  • Relative — contextual: 1 year ago

Sub-second precision, monotonic time, and modern APIs

Beyond second- and millisecond-precision timestamps, modern code routinely works with microseconds, nanoseconds, and a distinction between wall-clock time and monotonic time. The newer JavaScript Temporal API exposes nanosecond-precision instants directly; POSIX time_t remains the storage type underneath, and on 32-bit signed time_t a Y2038 overflow ceiling still applies.

  • Seconds (10 digits) — the canonical POSIX time_t format
  • Milliseconds (13 digits) — JavaScript Date and most web APIs
  • Microseconds (16 digits) — high-resolution logging, Chrome/WebKit timestamps, Postgres timestamp precision 6
  • Nanoseconds (19 digits) — Temporal.Instant.epochNanoseconds (BigInt), Java Instant, Go time.UnixNano()
  • Wall-clock time vs monotonic time: use Date.now() / time() for storing moments; use performance.now() / clock_gettime(CLOCK_MONOTONIC) for measuring durations
  • Time-zone abbreviations (EST, PST, JST, IST, CST) are ambiguous — always use an IANA name like America/New_York or Asia/Tokyo in code
  • POSIX time_t on 32-bit systems overflows on 2038-01-19; 64-bit time_t is the modern standard