Epoch Time Converter
Convert Unix timestamps to human-readable dates — and back. Live current timestamp updates every second.
Timestamp → Date
10-digit (seconds) or 13-digit (milliseconds) accepted
Date → Timestamp
YYYY-MM-DD or YYYY-MM-DD HH:MM:SS (treated as UTC)
Notable Unix Timestamps
Useful reference points — paste any of these into the converter above.
| Unix Timestamp | UTC Date & Time | Note |
|---|---|---|
| 0 | Jan 1, 1970 00:00:00 UTC | Unix Epoch — time zero |
| 1000000000 | Sep 9, 2001 01:46:40 UTC | One billion seconds |
| 1234567890 | Feb 13, 2009 23:31:30 UTC | Famous "Epoch Day" |
| 1500000000 | Jul 14, 2017 02:40:00 UTC | 1.5 billion seconds |
| 1700000000 | Nov 14, 2023 22:13:20 UTC | 1.7 billion seconds |
| 2000000000 | May 18, 2033 03:33:20 UTC | 2 billion seconds |
| 2147483647 | Jan 19, 2038 03:14:07 UTC | Year 2038 Problem — 32-bit max |
What Is Epoch Time?
Epoch time — also called Unix time or a Unix timestamp — is a single integer that counts the number of seconds elapsed since January 1, 1970 at 00:00:00 UTC. No time zones. No daylight saving. No ambiguity. Just one number.
Each second that passes, the timestamp increases by exactly 1 — simultaneously, everywhere on earth. A server in Tokyo and a server in New York logging the same event at the same instant record the exact same integer. The live widget at the top of this page shows the current value.
That's why developers default to Unix timestamps for storing dates in databases, log files, APIs, and anywhere time needs to be compared or calculated across time zones. Human-readable dates like "June 3, 2:30 PM EST" are for display only — the underlying storage is almost always a Unix timestamp.
📊 The Unix timestamp format is defined in IEEE Std 1003.1 (POSIX) and is the native time representation for Linux, macOS, and most Unix-based operating systems — which power approximately 96.3% of the world's top 1 million web servers. — NIST Time & Frequency
Why Does Unix Time Start on January 1, 1970?
Short answer: it was a convenient round number when Unix was being developed in the early 1970s. The original Unix developers at Bell Labs needed an epoch — a fixed reference point — and January 1, 1970 was recent enough to avoid large numbers while being far enough in the past to cover historical dates they'd need to work with.
There's nothing mathematically special about it. Earlier systems used different epochs — some used January 1, 1900 (used in NTP), others used January 1, 1904 (classic Mac OS). Unix happened to win the adoption war, and its 1970 epoch became the universal standard.
One practical consequence: negative timestamps are valid in the Unix spec and represent dates before 1970. -86400 = December 31, 1969. Most modern 64-bit systems handle them correctly. This converter covers 1970 onwards (positive timestamps only).
Seconds vs Milliseconds — Which Are You Looking At?
The original Unix timestamp counts seconds. A 10-digit number like 1717372800 is seconds. JavaScript's Date.now() returns milliseconds — that's a 13-digit number like 1717372800000.
The rule of thumb: 10 digits = seconds, 13 digits = milliseconds. This converter auto-detects which you've pasted. If the number is ≥ 10¹² (13+ digits), it's treated as milliseconds. Otherwise, seconds.
| Format | Digits | Example | Used In |
|---|---|---|---|
| Unix (seconds) | 10 | 1717372800 | Linux, Python, PHP, databases |
| Unix (milliseconds) | 13 | 1717372800000 | JavaScript, Java, C# |
| Unix (microseconds) | 16 | 1717372800000000 | Python datetime, PostgreSQL |
| Unix (nanoseconds) | 19 | 1717372800000000000 | Go, Rust, high-precision logs |
How to Get the Current Epoch Time in Code
Math.floor(Date.now() / 1000) // seconds Date.now() // milliseconds
import time int(time.time()) # seconds time.time_ns() // 1_000_000 # milliseconds
time() // seconds round(microtime(true) * 1000) // milliseconds
time.Now().Unix() // seconds time.Now().UnixMilli() // milliseconds
UNIX_TIMESTAMP() -- MySQL EXTRACT(EPOCH FROM NOW()) -- PostgreSQL
The Year 2038 Problem
On January 19, 2038 at 03:14:07 UTC, 32-bit Unix timestamps will overflow. The maximum value a 32-bit signed integer can hold is 2,147,483,647 — that's the timestamp for that exact moment. One second later, the clock rolls over to −2,147,483,648, which most systems will interpret as December 13, 1901.
Modern 64-bit systems are not affected — a 64-bit signed integer can represent timestamps up to the year 292,277,026,596. The risk is in legacy embedded systems, old firmware, and anywhere 32-bit time_t is still in use. The Y2K-scale migration to 64-bit time handling has been ongoing since the 2000s, but old hardware and industrial systems remain vulnerable.
The timestamp 2147483647 is the last safe second for 32-bit systems.
Frequently Asked Questions
What is a Unix timestamp?
A Unix timestamp is an integer counting the number of seconds since January 1, 1970 00:00:00 UTC. It's the universal way computers store and compare times — no time zones, no ambiguity, no daylight saving adjustments.
What is epoch time?
Epoch time and Unix time are the same thing — both refer to the count of seconds since the Unix epoch (January 1, 1970). The word "epoch" just means the fixed reference point from which time is measured.
How do I convert a Unix timestamp to a date?
Paste the timestamp into the converter above — it converts instantly. Manually: divide by 86400 to get days since 1970, then count forward. For code: use Date(timestamp * 1000) in JavaScript, or datetime.fromtimestamp(ts) in Python.
What is timestamp 0 in Unix time?
Timestamp 0 is January 1, 1970 00:00:00 UTC — the Unix epoch itself. It's midnight at the start of January 1st, 1970, in Coordinated Universal Time.
What's the difference between a 10-digit and 13-digit timestamp?
10-digit timestamps count seconds (used in Linux, Python, PHP, databases). 13-digit timestamps count milliseconds (used in JavaScript's Date.now()). To convert: multiply seconds × 1000 to get milliseconds, or divide milliseconds ÷ 1000 to get seconds.
What is the Year 2038 Problem?
On January 19, 2038 at 03:14:07 UTC, 32-bit systems storing Unix timestamps will overflow. The max 32-bit signed integer (2,147,483,647) is reached at that exact second. One second later it rolls over to a negative number. Modern 64-bit systems handle timestamps until the year 292 billion — not a practical concern.
Can Unix timestamps be negative?
Yes, in the Unix specification. Timestamp -86400 = December 31, 1969 00:00:00 UTC. Most modern 64-bit systems handle them correctly. This converter handles positive timestamps (1970 onwards) only — enter a positive integer to convert.