Epoch Converter & Live Unix Timestamp Clock
Convert Unix timestamps to dates, dates to epoch time, and seconds to milliseconds in one browser tool. The live epoch clock shows the current Unix time, UTC, ISO 8601, and timezone-aware output.
Choose the right epoch converter
The homepage is the broad epoch converter. For faster answers, use the focused converter that matches your input: epoch to time when you already have a Unix integer, date to epoch when you start with a human date, and the timestamp reference when you need copyable Unix time values for today, week, month, or year.
What is a Unix timestamp?
A Unix timestamp is the number of seconds since January 1, 1970 at 00:00:00 UTC. It is also called epoch time or POSIX time. Unix time conversion does not include leap seconds. The value is a single integer. It points to one moment. The integer does not depend on timezone or locale. Almost every language, database, and operating system supports epoch timestamps. They are the universal standard for storing and sending time 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.
Unix time conversion: how to convert epoch 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
Modern code uses more than seconds and milliseconds. It also handles microseconds and nanoseconds. Code distinguishes wall-clock time from monotonic time. The newer JavaScript Temporal API exposes nanosecond-precision instants directly. POSIX time_t still sits underneath. On 32-bit signed time_t the Y2038 overflow limit 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
The current Unix timestamp, live
The clock at the top of this page updates every second, showing the current epoch in seconds, the current time in milliseconds, and the date. The same instant appears five ways: 10-digit epoch seconds, 13-digit milliseconds, ISO 8601, UTC string, and a friendly local format. The same converter doubles as a datetime calculator — use it as a time and date changer between timezones or between epoch and human dates.
- Live clock with seconds and date / current epoch time / current Unix time — shown live at the top of the page
- Current time in ms (milliseconds) — the same instant as Date.now() in JavaScript
- Current timestamp / current Unix timestamp — the canonical 10-digit Unix seconds value
- Current week — to find the start of this week as an epoch, use the Reference page year/month/week timestamps
- Datetime calculator — for "date + N days = epoch?" use the Date → Epoch tab with the computed wall-clock value
- Time and date changer — pick a new timezone in the converter and the same instant changes its display
- Unix to unix (between systems): the integer is the same; the display changes per timezone
- Timestamp unix time — same number under three different names: timestamp, unix time, epoch time
Epoch unix timestamp converter — quick reference values
Round-number epoch values that come up often when debugging or writing tests. Each value is paired with the matching ISO 8601 datetime so you can sanity-check at a glance. All instants are in UTC.
- 0 → 1970-01-01T00:00:00Z (the epoch origin)
- 86400 → 1970-01-02T00:00:00Z (one day after epoch)
- 1000000000 → 2001-09-09T01:46:40Z (ten-digit milestone)
- 1500000000 → 2017-07-14T02:40:00Z (mid-2017 reference)
- 1700000000 → 2023-11-14T22:13:20Z (recent reference)
- 2000000000 → 2033-05-18T03:33:20Z (future reference)
- 2147483647 → 2038-01-19T03:14:07Z (32-bit signed int max — Y2038 boundary)
- 253402300799 → 9999-12-31T23:59:59Z (PostgreSQL year-9999 boundary)
Convert between Unix timestamps, dates, and UTC
This converter handles every direction in one place. Paste any wall-clock value to convert a date to a Unix timestamp, or paste an epoch integer to get the matching UTC datetime for log parsing. A 13-digit value is auto-detected as milliseconds and converted to seconds. POSIX time, Unix time, and epoch time are names for the same core timestamp model.
- Convert time to Unix timestamp — paste any wall-clock date, get seconds and milliseconds
- Epoch to UTC — paste an epoch integer, see the matching UTC datetime
- Millis to timestamp — 13-digit values are auto-detected as milliseconds and converted to seconds
- Posix time converter — POSIX time is just another name for Unix time; same tool, same operation
- Unix time conversion in any direction — date ↔ epoch, sec ↔ ms, local ↔ UTC
Computer systems, local time, and the January 19 2038 limit
Unix time is the timekeeping standard used by computer systems worldwide — from servers and databases to embedded devices and operating systems. Internally these computer systems store time as a Unix integer, then render it as local time for the viewer. The convention has one famous limit: on January 19 2038 at 03:14:07 UTC, 32-bit signed Unix timestamps overflow. Modern 64-bit computer systems are unaffected. Legacy 32-bit deployments still need attention before that date.
- Computer systems that count time as Unix integers: Linux, macOS, Windows, BSD, iOS, Android, and every major database engine
- Local time vs UTC: the timestamp itself is in UTC; local time is just one of many possible renderings
- January 19 2038 at 03:14:07 UTC — when 32-bit signed Unix timestamps reach 2,147,483,647 and overflow
- 64-bit computer systems extend the safe range to about year 292 billion — far beyond practical concerns
- Local time depends on timezone offset and daylight saving rules — apply only at display, never at storage
How this converter calculates
Every conversion on this page runs entirely in your browser using the standard POSIX definition of Unix time — seconds since 1970-01-01 00:00:00 UTC, with no leap seconds. The timestamps you enter are never sent to a server; the math happens locally in JavaScript. Times are computed in UTC and rendered to your chosen timezone only at display.
FAQ
- Which epoch converter should I use?
- Use Epoch to Date when you already have a Unix timestamp and need readable time. Use Date to Epoch when you have a calendar date, time, or datetime and need Unix seconds or milliseconds.
- How do I convert a Unix timestamp to a readable date?
- Paste your timestamp in the Epoch → Date tab above and click Convert. The tool auto-detects whether your timestamp is in seconds (10 digits) or milliseconds (13 digits) and shows the result in ISO 8601, UTC, and a friendly format for any timezone.
- How do I convert a date or time to Unix timestamp?
- Open the Date → Epoch tab, enter the date, time, and timezone, then copy the Unix timestamp in seconds or milliseconds.
- What is the difference between Unix time in seconds and milliseconds?
- A 10-digit timestamp (e.g. 1700000000) is in seconds. A 13-digit timestamp (e.g. 1700000000000) is in milliseconds. JavaScript's Date.now() returns milliseconds; most server-side languages (Python, PHP, Go) return seconds. Multiply by 1000 to convert seconds to milliseconds.
- How do I convert milliseconds to seconds?
- Divide the millisecond timestamp by 1000. In JavaScript, use Math.floor(milliseconds / 1000) when you need whole Unix seconds. To convert seconds back to milliseconds, multiply by 1000.
- What is a 16-digit Unix timestamp?
- A 16-digit Unix timestamp usually represents microseconds since the Unix epoch. Divide it by 1,000,000 to get seconds, or by 1000 to get milliseconds for JavaScript Date.
- What is the difference between Unix time and UTC?
- Unix time is a count of seconds elapsed since a fixed reference point (1970-01-01 00:00:00 UTC). UTC is the time standard that defines that reference point. A Unix timestamp always represents the same moment in UTC regardless of your local timezone.
- Can a Unix timestamp be negative?
- Yes. Timestamps before January 1, 1970 00:00:00 UTC are negative. For example, -86400 corresponds to December 31, 1969 00:00:00 UTC.
- What is the Year 2038 problem?
- Legacy systems that store Unix timestamps as 32-bit signed integers will overflow on January 19, 2038 at 03:14:07 UTC (the maximum value is 2,147,483,647). Modern 64-bit systems are unaffected and can represent dates billions of years in the future.