Epoch Time Converter: Unix Timestamp to Date and Back
Paste a Unix timestamp into this epoch time converter and see the date in UTC and your local time, or type a date and get the epoch. Seconds, milliseconds and microseconds are detected for you, and the current Unix time is live at the top.
By Troopus · Updated: October 28, 2026
- ⏱ Live Unix time
- 🔎 Auto-detects units
- 📋 One-click copy
- 🔒 100% private
Convert epoch time online
Time zone
What is epoch time, and what does an epoch time converter do?
Epoch time, also called Unix time or a Unix timestamp, is the number of seconds that have passed since 00:00:00 UTC on January 1, 1970. It is one plain number, so it is easy to store, sort and compare, and it means the same moment in every time zone.
Computers like a single number better than a calendar. A timestamp of 1700000000 is not "November 14" in one place and "November 15" in another. It is one instant, and each viewer turns it into local wall-clock time. That is why databases, APIs, log files and JWT tokens use it, and why an epoch time converter is a daily tool for developers.
The POSIX standard defines "seconds since the Epoch" as an approximation of elapsed time, where every day counts as exactly 86,400 seconds. Leap seconds are not counted separately, so Unix time does not show a 23:59:60 moment.
| Epoch seconds | UTC date and time |
|---|---|
| 0 | January 1, 1970 00:00:00 |
| 946684800 | January 1, 2000 00:00:00 |
| 1700000000 | November 14, 2023 22:13:20 |
| 2147483647 | January 19, 2038 03:14:07 |
How does the epoch time converter turn a timestamp into a date?
To convert an epoch timestamp to a readable date, paste it into the box above. The converter detects seconds, milliseconds or microseconds and shows the date in UTC, in your local time zone, as an ISO 8601 string and as a relative time such as "3 days ago". Each value has its own copy button.
Searching for epoch to human readable date? Paste the number and read the result. Timestamp to date works by multiplying the seconds by 1,000 to get milliseconds, then letting the browser build the calendar date. Doing it by hand is possible but tedious, so the epoch time converter handles it, because you need to handle leap years and the time zone offset.
Example: 1705314600 is January 15, 2024 at 10:30:00 UTC. In New York that moment is 05:30:00 EST, and in Tokyo it is 19:30:00 JST. Open the "Time zone" section under the tool to pick any zone from the list. The epoch value never changes, only the way it is written.
Can epoch time be negative?
Yes. Negative numbers count backward from 1970. A value of -1 is December 31, 1969 at 23:59:59 UTC. The converter accepts a minus sign, which is useful for birthdates and other historical dates.
How do I use a Unix timestamp converter to turn a date into epoch time?
To convert a date to a Unix timestamp, type it into the "Date to epoch" box in year-month-day order, for example 2024-01-15 10:30:00. You get epoch seconds and milliseconds instantly. Add Z or an offset such as +02:00 to fix the zone, otherwise your selected time zone is used.
This epoch time converter box accepts ISO 8601 style dates, with or without a time, a space or a T between date and time, and fractions of a second. It also understands common written dates such as "Mon, 15 Jan 2024 10:30:00 GMT". If you give only a date, the time is taken as midnight.
| You type | Zone used | Epoch seconds |
|---|---|---|
| 2024-01-15T10:30:00Z | UTC (from the Z) | 1705314600 |
| 2024-01-15 05:30:00-05:00 | UTC-5 (from the offset) | 1705314600 |
| 2000-01-01 | UTC when you pick UTC | 946684800 |
The same moment gives the same number whichever way you write it. That is the quick test that you entered the right zone.
Seconds, milliseconds or microseconds: how can I tell?
Count the digits. For dates near today, a 10-digit timestamp is seconds, 13 digits is milliseconds, 16 digits is microseconds and 19 digits is nanoseconds. The converter uses magnitude to choose the unit and tells you which one it picked, so you can spot a mismatch right away.
| Unit | Digits | Value | Common source |
|---|---|---|---|
| Seconds | 10 | 1700000000 | Unix date +%s, Python time.time() (as a float), most APIs |
| Milliseconds | 13 | 1700000000000 | JavaScript Date.now(), Java |
| Microseconds | 16 | 1700000000000000 | Some databases and tracing tools |
| Nanoseconds | 19 | 1700000000000000000 | Go UnixNano(), some log systems |
The detection rule is simple: values below 100 billion are seconds, below 100 trillion are milliseconds, below 100 quadrillion are microseconds, and anything larger is nanoseconds. That works for every date from 1970 until about the year 5138 in seconds. A timestamp from the distant past or future can be misread, so check the "Detected" line.
If a date shows up in January 1970, you probably passed milliseconds to something that expected seconds. If it lands tens of thousands of years in the future, the opposite happened.
How do I get the current epoch time in code?
Most languages have a one-line call. In JavaScript use Math.floor(Date.now() / 1000), in Python int(time.time()), and in a Unix shell date +%s. The live counter at the top of this page shows the same Unix time now, with a copy button.
| Language | Seconds |
|---|---|
| JavaScript | Math.floor(Date.now() / 1000) |
| Python | int(time.time()) |
| Bash / macOS / Linux | date +%s |
| PHP | time() |
| Java | Instant.now().getEpochSecond() |
| Go | time.Now().Unix() |
| PostgreSQL | extract(epoch from now()) |
To go the other way in JavaScript, new Date(1700000000 * 1000).toISOString() returns "2023-11-14T22:13:20.000Z". Remember the multiplication: JavaScript dates use milliseconds.
What is the Year 2038 problem?
The Year 2038 problem is an overflow in systems that store Unix time as a signed 32-bit integer. The largest value, 2,147,483,647, is January 19, 2038 at 03:14:07 UTC. One second later the number wraps to a negative value and the date jumps back to 1901. Systems with 64-bit time are not affected.
Most modern operating systems and languages already use 64-bit timestamps, which will not overflow for hundreds of billions of years. The risk is older embedded devices, file formats and databases with 32-bit fields. Try the third example chip above to see the exact overflow moment.
A related limit is the range of a JavaScript date: about 271,000 years either side of 1970. The converter shows a friendly message instead of an error if you paste something larger.
Frequently asked questions
What is the current Unix timestamp, or Unix time now?
It is shown live at the top of the converter and changes every second. For a rough reference, the count passed 1.7 billion in November 2023. Click "Copy current time" to put the seconds value on your clipboard.
How do I convert epoch time to a human readable date?
Paste the number into the "Timestamp or date" box. The page detects whether it is seconds, milliseconds or microseconds, then writes the date in UTC and your local zone, plus an ISO 8601 string. No button is needed.
Is a Unix timestamp UTC or local time?
A Unix timestamp has no time zone. It counts seconds since 00:00:00 UTC on January 1, 1970, so it names one exact moment. Only the human-readable date you build from it depends on the zone you choose to display.
Why is my timestamp 13 digits long?
A 13-digit timestamp is in milliseconds, the unit used by JavaScript Date.now() and Java. Divide by 1,000 to get seconds. The converter detects this automatically and labels the unit as milliseconds in the line under the input box.
Does epoch time include leap seconds?
No. POSIX Unix time treats every day as exactly 86,400 seconds, so leap seconds are not counted as separate values. For most software this makes no difference, but it matters for precise astronomy and some scientific logs.
Can epoch time be negative?
Yes. A negative timestamp is a moment before January 1, 1970 UTC. For example, -1 is December 31, 1969 at 23:59:59 UTC. You can type a minus sign into the converter to see dates from before the epoch.
How do I convert a timestamp in Excel or Google Sheets?
For seconds, use =A1/86400+DATE(1970,1,1) and format the cell as a date and time. For milliseconds, divide by 86400000 instead. The result is in UTC, so add or subtract your zone offset in days if you need local time.
Is this epoch converter private?
Yes, it is private. The conversion runs entirely in your browser with JavaScript date functions. Nothing you type is uploaded, logged or stored, and the page makes no network requests while you use the tool.