Epoch Time Converter
Convert Unix timestamps to UTC dates or turn a date into epoch seconds.
How to use this epoch time converter
- Choose the conversion mode
Select Epoch to date or Date to epoch in the Conversion mode field.
- For epoch to date
Enter the Unix timestamp in seconds into the Epoch timestamp (seconds) field.
- For date to epoch
Pick the date in Calendar date, then set Hour (UTC), Minute (UTC), and Second (UTC) as needed.
- Read the result
The calculator shows the UTC value, Unix milliseconds, and Day of week.
How this epoch time converter works
This epoch time converter translates between Unix timestamps and human-readable UTC dates. Unix time — also called POSIX time or epoch time — counts the number of seconds that have elapsed since the Unix epoch, defined as midnight UTC on January 1, 1970 (1970-01-01T00:00:00Z). This single-integer representation is the de-facto standard for storing and transmitting timestamps in databases, APIs, log files, JWT tokens, and virtually every modern programming language. The converter handles both directions: entering a numeric timestamp returns the corresponding UTC date, day of the week, and millisecond equivalent, while entering a calendar date and time returns the epoch value in seconds and milliseconds.
Unix time = seconds elapsed since 1970-01-01T00:00:00Z To convert the Unix timestamp 1,700,000,000 to a date: starting from 1970-01-01 00:00:00 UTC, add 1,700,000,000 seconds. This equals 19,675 days, 17 hours, 46 minutes, and 40 seconds. The resulting UTC date is 2023-11-14 at 22:13:20 UTC, which falls on a Tuesday. The millisecond equivalent is 1,700,000,000,000. Conversely, entering November 14, 2023 at 22:13:20 UTC returns an epoch value of exactly 1,700,000,000.
Timestamp 0 converts to 1970-01-01 00:00:00 UTC (Thursday). The millisecond equivalent is 0.
Timestamp 1,704,000,000 converts to 2023-12-31 12:00:00 UTC (Sunday). Entering that date and time in Date to epoch mode returns 1,704,000,000.
- ✓ All calculations are in UTC. Local-time conversions require applying the appropriate time-zone offset after the conversion.
- ✓ Leap seconds are not counted. Like POSIX, this converter treats every day as exactly 86,400 seconds, which matches the behavior of most programming languages and operating systems.
- ✓ Negative timestamps represent dates before the epoch (January 1, 1970). For example, −86400 corresponds to December 31, 1969.
- ✓ Millisecond timestamps should be divided by 1,000 before entry; the converter accepts seconds as input and displays the millisecond equivalent in the results.
- JavaScript's Date.now() and Java's System.currentTimeMillis() return milliseconds, not seconds — divide by 1,000 before entering the value here, or use the millisecond output for comparison.
- The Year 2038 problem affects 32-bit signed-integer timestamps, which will overflow on January 19, 2038 at 03:14:07 UTC. Most modern systems have migrated to 64-bit timestamps.
- When debugging API responses or log files, watch for timestamps that seem off by exactly 3,600 or 7,200 seconds — this usually indicates a time-zone offset was applied (or omitted) somewhere in the pipeline.
- Epoch time is always monotonically increasing (ignoring leap-second adjustments), which makes it ideal for sorting events, computing durations, and generating unique time-based identifiers.
- IEEE Std 1003.1 (POSIX) — definition of Seconds Since the Epoch
- Unix epoch origin — The Unix Heritage Society and Bell Labs documentation
- RFC 3339 — Date and Time on the Internet: Timestamps
What are Unix timestamps?
A Unix timestamp is the number of seconds elapsed since midnight UTC on January 1, 1970 — the Unix epoch. This single integer is the de-facto standard for representing time in databases, APIs, log files, and most programming languages. Because it is time-zone agnostic and monotonically increasing, it simplifies sorting, duration calculations, and time-based comparisons. JavaScript's Date.now() and many APIs return milliseconds (1,000 × seconds), so divide by 1,000 before entering a millisecond value here. Negative timestamps represent dates before 1970; for example, −86400 is exactly one day before the epoch.
Developer use cases for epoch time
Developers use Unix timestamps when storing event times in databases, serializing dates in JSON APIs, generating time-based cache keys, and debugging log entries. Database columns often store timestamps as integers for efficient indexing and range queries. API responses frequently return epoch seconds or milliseconds to avoid time-zone ambiguity. When debugging, converting a raw timestamp from a log or JWT claim to a human-readable date quickly reveals whether the value is correct or off by a time-zone factor. Epoch time is also used for rate limiting, session expiry, and generating sortable unique identifiers in distributed systems.
Epoch time converter FAQs
What is the Unix epoch?
The Unix epoch is the reference point from which Unix time is measured: midnight UTC on January 1, 1970 (1970-01-01T00:00:00Z). A timestamp of 0 corresponds to that exact moment.
Why does my JavaScript timestamp have more digits?
JavaScript's Date.now() returns milliseconds since the epoch, not seconds. Divide by 1,000 to convert to the seconds-based format used by this tool, or compare directly with the milliseconds output.
Can I enter a negative timestamp?
Yes. Negative values represent dates before the epoch. For example, −86400 corresponds to 1969-12-31T00:00:00Z, exactly one day before the epoch.
Does this handle leap seconds?
No, and this matches the POSIX standard. POSIX time assumes every day is exactly 86,400 seconds. The 27 leap seconds inserted since 1972 are not individually represented, which means UTC and Unix time can differ by up to a second at leap-second boundaries.
What is the Year 2038 problem?
Systems storing Unix time as a 32-bit signed integer will overflow on January 19, 2038 at 03:14:07 UTC, wrapping to a large negative number and producing dates in 1901. Most modern platforms now use 64-bit timestamps, which will not overflow for over 290 billion years.