Epoch Unix Timestamp Converter — Convert Time to Unix Timestamp, Epoch to UTC

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

Current epoch time, current time in ms, live clock with seconds and date

The clock at the top of this page updates every second. It shows the current epoch in seconds and the date. It answers "current epoch", "current Unix time", "current time in ms", and "current timestamp" queries at once. 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 time to Unix timestamp: epoch to UTC, millis to timestamp, posix time converter

This epoch unix timestamp converter handles every direction in one place. Use it to convert time to Unix timestamp from any wall-clock value. Run epoch to UTC for log parsing. Do millis to timestamp conversion when JavaScript hands you a 13-digit value. Use it as a posix time converter for shell or C log files. The same tool answers unix time conversion queries. It works with seconds, milliseconds, microseconds, and ISO 8601 strings.

• 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
• Epoch unix timestamp converter and unix time converter are different names for the same tool on this page

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