Unix Timestamp & Epoch Converter
Accurately convert between Unix epoch timestamps (seconds, milliseconds, and microseconds) and human-readable calendar dates in UTC, ISO 8601, and local time zones.
Current Unix Timestamp (Epoch)
Milliseconds: 1790593930000 | Mon, 28 Sep 2026 11:12:10 GMT
Timestamp to Human Date
Human Date to Timestamp
Epoch Timestamp Quick Reference Table
| Duration | Seconds | Formula / Representation |
|---|---|---|
| 1 Minute | 60 | 60 seconds |
| 1 Hour | 3,600 | 60 × 60 |
| 1 Day | 86,400 | 24 × 3600 |
| 1 Week | 604,800 | 7 × 86400 |
| 1 Month (30.44 days) | 2,629,743 | Average Gregorian month |
| 1 Year (365 days) | 31,536,000 | 365 × 86400 |
| Year 2038 Problem (32-bit max) | 2,147,483,647 | January 19, 2038, 03:14:07 UTC |
Comprehensive Guide to Unix Time & The Epoch Standard
In computing, Unix time (also known as POSIX time, Epoch time, or Unix timestamp) is a universal system for tracking time points. It is defined as the elapsed duration in seconds since 00:00:00 Coordinated Universal Time (UTC) on Thursday, January 1, 1970, not counting leap seconds. This arbitrary reference moment in history is universally referred to as the Unix Epoch.
Before the widespread adoption of the Unix epoch standard in operating systems, various computing platforms tracked time using proprietary, architecture-dependent schemes. For instance, early IBM mainframes tracked clock cycles, and CP/M used customized date offsets. In the early 1970s, Dennis Ritchie and Ken Thompson chose January 1, 1970 as a convenient, rounded epoch milestone when designing the original Unix operating system on Digital Equipment Corporation (DEC) PDP-11 computers. Today, nearly all contemporary operating systems—including Linux, macOS, iOS, Android, and Windows—along with the internet protocols governing HTTP, TLS, DNS, and NTP, rely on Unix epoch timestamps for scheduling, caching, token signing, and event ordering.
Understanding Timestamp Precisions: Seconds, Milliseconds, & Microseconds
Different software ecosystems use different granularities when representing Unix timestamps. Understanding these differences is essential for troubleshooting serialization errors, API mismatches, and database query anomalies:
Seconds (10 Digits)
Example: 1711620000
The classic POSIX standard. Used natively by Linux kernel system calls, C/C++ time_t, Python time.time(), PHP time(), and relational SQL databases (e.g. MySQL UNIX_TIMESTAMP()). Suitable for general logging, expiration dates, and file timestamps.
Milliseconds (13 Digits)
Example: 1711620000000
The standard for JavaScript (Date.now()), Java (System.currentTimeMillis()), and modern JSON API schemas. Crucial for web user interfaces, animations, and client-side telemetry where sub-second accuracy is necessary.
Microseconds / Nanoseconds
Example: 1711620000000000 (16-19 Digits)
Employed in high-frequency trading (HFT), distributed tracing frameworks (OpenTelemetry), and Golang time.Now().UnixNano(). Enables microsecond-level synchronization between microservices and kernel tracing profilers.
The Year 2038 Problem (Y2038): What Every Engineer Should Know
The Year 2038 Problem (historically termed the Unix Millennium Bug or Y2038) is a computing issue caused by 32-bit hardware architectures and legacy software libraries that store epoch time in a signed 32-bit integer (int32).
A signed 32-bit binary integer can only represent values from -2,147,483,648 up to +2,147,483,647. Because time counts continuously upwards, at 03:14:07 UTC on Tuesday, January 19, 2038, the counter will reach its maximum capacity and roll over into negative numbers (-2,147,483,648). Legacy systems that have not been patched will suddenly interpret the year as 1901, precipitating widespread logic failures in embedded systems, automotive controllers, medical devices, and older database engines.
time_t as a signed 64-bit integer (int64). A 64-bit integer can record up to 9,223,372,036,854,775,807 seconds—sufficient to accurately measure dates until approximately the year 292,277,026,596 AD, completely eliminating overflow concerns for modern web applications.Working with Unix Timestamps Across Programming Languages
Below is an idiomatic cheatsheet demonstrating how to retrieve the current epoch timestamp, convert epoch integers into formatted date strings, and parse date strings into timestamps across popular backend and frontend programming environments:
JavaScript & TypeScript (Node.js & Browser)
// 1. Current timestamp in seconds & milliseconds
const epochSeconds = Math.floor(Date.now() / 1000);
const epochMillis = Date.now();
// 2. Convert epoch timestamp to Human Date
const date = new Date(epochSeconds * 1000);
console.log(date.toUTCString()); // "Sun, 28 Mar 2026 12:00:00 GMT"
console.log(date.toISOString()); // "2026-03-28T12:00:00.000Z"
// 3. Convert Date string to epoch seconds
const parsedEpoch = Math.floor(new Date('2026-03-28T12:00:00Z').getTime() / 1000);Python 3
import time
from datetime import datetime, timezone
# 1. Current timestamp in seconds
now_seconds = int(time.time())
# 2. Convert epoch to formatted UTC string
dt = datetime.fromtimestamp(now_seconds, tz=timezone.utc)
print(dt.strftime('%Y-%m-%d %H:%M:%S UTC'))
# 3. Convert ISO string to epoch seconds
parsed_dt = datetime.fromisoformat('2026-03-28T12:00:00+00:00')
epoch = int(parsed_dt.timestamp())Go (Golang)
package main
import (
"fmt"
"time"
)
func main() {
// Current timestamp in seconds and nanoseconds
now := time.Now()
sec := now.Unix()
nano := now.UnixNano()
// Convert epoch to time object
t := time.Unix(sec, 0).UTC()
fmt.Println(t.Format(time.RFC3339))
}Java 8+ (java.time)
import java.time.Instant;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
// 1. Current epoch seconds & millis
long epochSec = Instant.now().getEpochSecond();
long epochMillis = Instant.now().toEpochMilli();
// 2. Convert to UTC String
String formatted = Instant.ofEpochSecond(epochSec)
.atZone(ZoneOffset.UTC)
.format(DateTimeFormatter.ISO_INSTANT);Key Historical & Future Epoch Milestones
Refer to this timeline of significant moments in computer history and distributed systems:
| Unix Timestamp | Calendar Date & Time (UTC) | Significance / Historical Event |
|---|---|---|
-2,147,483,648 | December 13, 1901, 20:45:52 UTC | Minimum value for signed 32-bit integer |
0 | January 1, 1970, 00:00:00 UTC | The official beginning of Unix Epoch time |
1,000,000,000 | September 9, 2001, 01:46:40 UTC | The 'Unix Billepoch' milestone celebrated by programmers |
1,500,000,000 | July 14, 2017, 02:40:00 UTC | 1.5 Billion seconds milestone |
2,000,000,000 | May 18, 2033, 03:33:20 UTC | 2.0 Billion seconds milestone |
2,147,483,647 | January 19, 2038, 03:14:07 UTC | Maximum signed 32-bit integer (Year 2038 overflow point) |
Frequently Asked Questions
Explore Related Tools
Hand-picked utilities and calculators related to this tool.
