Convert any Unix timestamp to a human-readable date — or pick a date to get its timestamp. Auto-detects seconds vs milliseconds. ISO 8601, RFC 2822, relative time and timezone support.
A Unix timestamp (also called Unix time, POSIX time, or epoch time) is a way of representing a point in time as a single integer — the number of seconds elapsed since January 1, 1970 at 00:00:00 UTC. This origin is called the Unix epoch. Because it is a simple integer, timestamps are trivial to store, compare, sort, and transmit across systems and programming languages.
The Unix timestamp is the universal language of time in computing. Databases store event times as timestamps, HTTP headers use them for cache expiry, JWT tokens carry an exp (expiration) timestamp, and log files are often sorted by them. Every time you check "when was this record created?" in a modern application, a Unix timestamp is involved.
The original Unix timestamp is in seconds, but many languages and APIs — particularly in JavaScript and Java — work natively in milliseconds. Confusing the two is one of the most common bugs when working with timestamps: a millisecond timestamp interpreted as seconds produces a date around the year 2527.
| Unit | Typical digits today | Example (May 2026) | Who uses it |
|---|---|---|---|
| Seconds | 10 digits | 1,747,000,000 | Unix/Linux, Python time.time(), Go time.Unix(), C time() |
| Milliseconds | 13 digits | 1,747,000,000,000 | JavaScript Date.now(), Java System.currentTimeMillis(), Redis |
| Microseconds | 16 digits | 1,747,000,000,000,000 | PostgreSQL, high-precision logs |
| Nanoseconds | 19 digits | 1,747,000,000,000,000,000 | Go time.Now().UnixNano(), InfluxDB |
This converter auto-detects seconds vs milliseconds based on the magnitude of the value: numbers larger than 9,999,999,999 (10 billion) are treated as milliseconds.
Here is how to get the current Unix timestamp in the most common languages:
Math.floor(Date.now() / 1000) // seconds
Date.now() // millisecondsimport time
int(time.time()) # seconds
int(time.time() * 1000) # millisecondsimport "time"
time.Now().Unix() // seconds
time.Now().UnixMilli() // millisecondsdate +%s # seconds
date +%s%3N # milliseconds (GNU date)time() // seconds
round(microtime(true) * 1000) // millisecondsOn 32-bit systems, Unix time is stored as a signed 32-bit integer, which can hold a maximum value of 2,147,483,647 — corresponding to January 19, 2038 at 03:14:07 UTC. After that moment, the integer overflows to a large negative number, causing dates to wrap back to December 1901.
Modern 64-bit systems are not affected: a 64-bit Unix timestamp can represent dates up to approximately the year 292,277,026,596. Most systems migrated to 64-bit long before 2038, but embedded systems, legacy databases, and some file systems still store 32-bit timestamps. The Unix timestamp 2147483647 can be entered in this tool to see the exact overflow boundary.
Unix timestamp 0 corresponds to Thursday, January 1, 1970 at 00:00:00 UTC. Negative timestamps represent moments before the epoch. For example, -86400 is December 31, 1969 at 00:00:00 UTC.
The maximum value of a 32-bit signed integer. After this second (January 19, 2038, 03:14:07 UTC), 32-bit systems overflow. This is the computing equivalent of Y2K for timestamps.
JSON Web Tokens use Unix timestamps (in seconds) for the iat (issued at), exp (expiration), and nbf (not before) claims. Paste any of these values into this converter to check when a token was issued or when it expires.
{
"sub": "user_123",
"iat": 1747000000, ← issued at: paste into converter
"exp": 1747086400 ← expires: paste into converter
}January 1, 1970 was chosen by the early Unix developers at Bell Labs as a convenient, round epoch date for their systems. It had no deep mathematical reason — it was simply close to when early Unix systems were being developed, and a round date makes mental arithmetic easier. Other systems use different epochs: Windows FILETIME starts on January 1, 1601; Apple's Core Data uses January 1, 2001.
Yes. Negative timestamps represent moments before January 1, 1970. For example, -1 is December 31, 1969 at 23:59:59 UTC, and -2208988800 is January 1, 1900. Most modern systems and languages support negative timestamps correctly, though some older databases and file systems do not.
ISO 8601 is an international standard using the format YYYY-MM-DDTHH:mm:ss.sssZ (e.g., 2025-05-16T10:30:00.000Z). It is the format used in JSON APIs, HTML datetime attributes, and most modern systems. RFC 2822 is an older Internet standard (used in email headers) with the format Day, DD Mon YYYY HH:mm:ss +ZZZZ (e.g., Fri, 16 May 2025 10:30:00 +0000). Both are commonly encountered in HTTP headers and log files.
Pass the timestamp (in milliseconds) to the Date constructor: new Date(1747000000000). If your timestamp is in seconds, multiply by 1000 first: new Date(1747000000 * 1000). Then use methods like .toISOString(), .toLocaleDateString(), or Intl.DateTimeFormat to format the output.
No. Unix time does not count leap seconds. Each day is defined as exactly 86,400 seconds, regardless of whether a leap second was inserted by the IERS. In practice, when a leap second occurs, systems using NTP either "smear" the second over a longer period or repeat the same Unix second twice. For most applications this difference is negligible, but for high-precision timekeeping (financial systems, scientific instruments) it matters.
JWT tokens contain a Base64url-encoded JSON payload as the middle segment (between the two dots). Decode it and look for the iat (issued at), exp (expiration), and nbf (not before) fields — all Unix timestamps in seconds. You can use the JWT Decoder on this site to extract and inspect all claims, then paste the timestamp values here to convert them.
On a 64-bit system, the maximum signed integer is 9,223,372,036,854,775,807, corresponding to approximately Sunday, December 4, 292,277,026,596 CE. This is not a practical concern — long before that date, the Sun will have engulfed the Earth. The real concern is 32-bit legacy systems, which overflow in 2038.
No. All conversion is done entirely in your browser using JavaScript's built-in Date object and the Intl.DateTimeFormat API. No data is sent to any server. The live counter and all calculations happen locally on your device.