Epoch Converter: Unix Timestamp to Date

This epoch converter shows the current Unix time and turns any timestamp into a readable date in UTC, ISO 8601 and your own time zone. It works in reverse too: pick a date and get its Unix timestamp in seconds and milliseconds. Seconds, milliseconds, microseconds and nanoseconds are detected automatically.

Current Unix epoch time

—

loading…

Shown from your device clock once the page loads.

Timestamp to date

Read asseconds (detected)
Seconds1700000000
Milliseconds1700000000000
ISO 8601 (UTC)2023-11-14T22:13:20.000Z
UTCTue, 14 Nov 2023 22:13:20 GMT
Your local time…
Relative…

Date to timestamp

Time zone

Pick a date and time to get its Unix timestamp.

Runs in your browser using your device clock and time zone. Nothing is sent anywhere.

How do you convert a Unix timestamp to a date?

To convert a Unix timestamp to a date, add that many seconds to 00:00:00 UTC on 1 January 1970 and then show the result in the time zone you want. Paste the timestamp above and the converter does it instantly; a 13-digit value is treated as milliseconds. The UTC and ISO 8601 results are the same everywhere, while the local time depends on your device's time zone.

How to use the Unix timestamp converter

  1. The box at the top is the current Unix timestamp from your clock. Press Convert now to load it into the converter.
  2. Timestamp to date: paste a number. Thousands separators are ignored, negative values (before 1970) and decimals work, and you can force the unit if auto-detect guesses wrong.
  3. You can also paste an ISO 8601 date such as 2026-10-18T09:30:00Z into the same box to convert date to epoch.
  4. Date to timestamp: pick a date and time, choose whether it is local time or UTC, and copy the epoch seconds or milliseconds.

Unix epoch time explained

POSIX defines Unix time as “seconds since the Epoch”, where the Epoch is 1970-01-01 00:00:00 UTC (POSIX.1-2017, Base Definitions 4.16). Every day counts as exactly 86,400 seconds, so leap seconds are not included and a Unix timestamp can be turned into a calendar date with plain arithmetic. One consequence: a timestamp has no time zone. The same number is the same instant in Tokyo and New York; only the way it is displayed changes.

Systems that stored Unix time in a signed 32-bit integer run out at 2147483647, which is 2038-01-19 03:14:07 UTC (the “Year 2038 problem”). Modern systems use 64-bit values, and JavaScript dates reach about 273,000 years either side of 1970.

Seconds or milliseconds? Reading a timestamp by its length

Unix time is defined in seconds, but many platforms count smaller units: JavaScript's Date.now() and Java's System.currentTimeMillis() return milliseconds, and some databases and logs use micro- or nanoseconds. For present-day dates the number of digits gives it away:

LengthUnitExample (same instant)
10 digitsseconds1700000000
13 digitsmilliseconds1700000000000
16 digitsmicroseconds1700000000000000
19 digitsnanoseconds1700000000000000000

Auto-detect uses magnitude: values below 100 billion are read as seconds (that covers dates up to the year 5138), below 100 trillion as milliseconds, and so on. To convert milliseconds to a date by hand, divide by 1000 first. If a converted date lands in 1970 or tens of thousands of years away, the unit is wrong.

ISO 8601 and time zones

The converter shows ISO 8601 in UTC, for example 2023-11-14T22:13:20.000Z, where the Z means zero offset from UTC. This is the profile described in RFC 3339 and the format JavaScript's toISOString() produces. When you paste a date, include a Z or an offset such as +02:00 to be unambiguous: per the ECMAScript date format, a date-only string is read as UTC but a date-time without an offset is read as your local time.

JavaScript   Math.floor(Date.now() / 1000)
Python       int(time.time())
Go           time.Now().Unix()
PostgreSQL   SELECT extract(epoch FROM now());
Shell        date +%s

JWTs store their exp and iat claims as Unix seconds; the JWT decoder converts them for you. Time-ordered IDs such as UUID v7 also start with a millisecond timestamp, which the UUID generator can extract.

Frequently asked questions

What is epoch time?

Epoch time is a way of writing a moment as a single number: the count of seconds since the Unix epoch, 00:00:00 UTC on 1 January 1970. For example, 1700000000 is 14 November 2023 at 22:13:20 UTC; the same number means the same instant in every time zone.

What is Unix time?

Unix time is the same thing as epoch time: the number of seconds that have elapsed since 1970-01-01T00:00:00Z, as defined by POSIX, with every day counted as exactly 86,400 seconds so leap seconds are ignored. Unix-like systems, databases and most programming languages use it to store and compare timestamps.

What is the epoch?

The epoch is the reference point a computer clock counts from. For Unix time it is midnight UTC at the start of 1 January 1970; other systems use other epochs, for example Windows FILETIME counts from 1601 and GPS time from 6 January 1980.

What is the epoch time now?

The epoch time now is shown live at the top of this page, in seconds and milliseconds, and updates every second from your device clock. It grows by exactly one every second; to get it in code use Math.floor(Date.now() / 1000) in JavaScript, time.time() in Python or date +%s in a terminal.

How to convert epoch time to date?

To convert epoch time to a date, paste the number into the converter above and read the UTC, ISO 8601 and local results. In code, multiply seconds by 1000 for JavaScript (new Date(1700000000 * 1000)), use datetime.fromtimestamp(ts, tz=timezone.utc) in Python, or date -u -d @1700000000 on Linux.