Convert epoch to human-readable date and vice versa:
1783860160 -> Sun, 12 Jul 2026 12:42:40 GMT
Supports Unix timestamps in seconds, milliseconds, microseconds and nanoseconds.
Input format for date to timestamp: RFC 2822, ISO, D-M-Y, M/D/Y, Y-M-D, etc. Strip 'GMT' to convert to local time.
What is the Unix epoch?
The Unix epoch (also called Unix time, POSIX time, or a Unix timestamp) is the number of seconds since January 1, 1970, 00:00:00 UTC, not counting leap seconds (ISO 8601: 1970-01-01T00:00:00Z). Strictly speaking, the epoch is Unix time 0, but people often use "epoch" as shorthand for Unix time in general. Some systems store epoch values as signed 32-bit integers, which can break on January 19, 2038, in the Year 2038 problem. This page converts timestamps in seconds (10 digits), milliseconds (13 digits), and microseconds (16 digits) into readable dates.
Human-readable time vs Seconds
| Human-readable time | Seconds |
|---|---|
| 1 hour | 3,600 seconds |
| 1 day | 86,400 seconds |
| 1 week | 604,800 seconds |
| 1 month (~30.437 days) | 2,629,743 seconds |
| 1 year (365.25 days) | 31,557,600 seconds |
Code examples
How to get the current epoch time and convert it to a human-readable date in your favorite programming language (epoch timestamp in seconds):import time; time.time()import time; time.ctime(1800000000)time()date('r', 1800000000);Math.floor(new Date().getTime()/1000.0)new Date(18000000001000).toLocaleString()long epoch = System.currentTimeMillis()/1000;String date = new java.text.SimpleDateFormat("MM/dd/yyyy HH:mm:ss").format(new java.util.Date(18000000001000));double now = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();auto date = std::chrono::system_clock::from_time_t(1800000000); std::cout << std::format("{:%F %T}", date);DateTimeOffset.Now.ToUnixTimeSeconds()new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(epoch).ToShortDateString();time.Now().Unix()time.Unix(1800000000, 0)
What is Unix Epoch Time?
Unix epoch time is a system for describing a point in time as a single number: the count of seconds that have elapsed since Thursday, January 1, 1970, at 00:00:00 Coordinated Universal Time (UTC). This reference point is called the Unix epoch, and it forms the backbone of timekeeping in virtually every modern operating system, programming language, and database.The concept was introduced with the Unix operating system at Bell Labs in the early 1970s. The engineers needed a compact, unambiguous way to store time. A single integer, free of timezone offsets, daylight saving rules, and calendar quirks, turned out to be the most elegant solution.
How Epoch Time Works in Practice
Every second that passes increments the Unix timestamp by one. At the epoch itself (January 1, 1970 00:00:00 UTC), the value is 0. Negative values represent dates before 1970.Epoch timestamps are timezone-independent. The integer 1735689600 means the same instant everywhere in the world. To display that instant in a local timezone, software applies the appropriate UTC offset after the fact.
Seconds vs. Milliseconds Timestamps
The original Unix timestamp counts in seconds and produces a 10-digit number for current dates. However, many modern platforms use millisecond precision, yielding a 13-digit number. JavaScript'sDate.now(), Java's System.currentTimeMillis(), and many REST APIs return milliseconds. Meanwhile, Unix shell commands like date +%s, Python's time.time(), and most database TIMESTAMP columns use seconds.Converting between the two is straightforward: multiply seconds by 1,000 to get milliseconds, or integer-divide milliseconds by 1,000 to get seconds.
The Y2038 Problem
The maximum value a signed 32-bit integer can store is 2,147,483,647, which corresponds to January 19, 2038 at 03:14:07 UTC. After that second, a 32-bit counter wraps around to its minimum negative value, jumping the date back to December 13, 1901. This is known as the Y2038 problem or the "Unix Millennium Bug." Most modern operating systems and languages have already transitioned to 64-bit timestamps, which won't overflow for approximately 292 billion years.Unix Timestamp FAQ
What is epoch time?
Epoch time (or Unix time) is the number of seconds elapsed since January 1, 1970 UTC.Why does Unix time start at January 1, 1970?
The Unix epoch was designated as January 1, 1970, for simplicity and alignment with early system architectures.What is the Y2038 problem?
The overflow of 32-bit Unix timestamps occurring in 2038, which is solved by using 64-bit values.What's the difference between seconds and milliseconds timestamps?
Seconds timestamps are 10 digits long, while milliseconds timestamps are 13 digits long.How do I get the current Unix timestamp?
Retrieve it using language utilities likeDate.now() / 1000 in JavaScript or time.time() in Python.