0
1970-01-01T00:00:00Z
946684800
2000-01-01T00:00:00Z
2147483647
2038-01-19T03:14:07Z — max for 32-bit signed int
9223372036854775807
~292 billion years — no practical overflow
86400000
60 × 60 × 24 × 1000
31536000
365 × 24 × 60 × 60 (non-leap)
2024-01-15T12:30:00Z
YYYY-MM-DDTHH:MM:SSZ — widely recommended
2024-01-15T07:30:00-05:00
YYYY-MM-DDTHH:MM:SS±HH:MM
Mon, 15 Jan 2024 12:30:00 +0000
Used in email headers and HTTP headers
2024-01-15T12:30:00.000Z
Subset of ISO 8601 with milliseconds
Mon, 15 Jan 2024 12:30:00 GMT
Used in HTTP headers (Last-Modified, Date)
01/15/2024
Ambiguous — avoid in APIs
15/01/2024
Ambiguous — avoid in APIs
2024-01-15
SQL DATE type, BigQuery, Redshift
20240115123000
Lexicographically sortable
Date.now()
Returns milliseconds since epoch
Math.floor(Date.now() / 1000)
Returns whole seconds
new Date(ts * 1000).toISOString()
Multiply by 1000 if ts is in seconds
Math.floor(new Date('2024-01-15T12:30:00Z').getTime() / 1000)import time; time.time()
Returns float with sub-second precision
from datetime import datetime, timezone datetime.fromtimestamp(ts, tz=timezone.utc)
Always pass tz=timezone.utc to avoid local timezone
from datetime import datetime, timezone
datetime.fromisoformat('2024-01-15T12:30:00+00:00').timestamp()SELECT EXTRACT(EPOCH FROM NOW())::BIGINT;
Returns whole seconds
SELECT to_timestamp(1705319400);
SELECT UNIX_TIMESTAMP();
SELECT FROM_UNIXTIME(1705319400);
time.Now().UnixNano()
Nanoseconds precision
time.Now().Unix()
SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs()
time()
Returns seconds; microtime(true) for float
date +%s
GNU/BSD date; on macOS same command works
+00:00
Coordinated Universal Time — no DST
-05:00 / -04:00
EST in winter, EDT in summer (DST)
-06:00 / -05:00
-07:00 / -06:00
-08:00 / -07:00
+00:00 / +01:00
BST (British Summer Time) in summer
+01:00 / +02:00
Germany, France, Italy, Poland, etc.
+05:30
No DST — half-hour offset
+08:00
No DST — entire country one timezone
+09:00
No DST
+10:00 / +11:00
DST in southern hemisphere summer (Oct–Apr)
+12:00 / +13:00
| Unit | Digits | Example | Range approx. |
|---|---|---|---|
| Seconds (s) | 10 | 1705319400 | 1970 – 2286 |
| Milliseconds (ms) | 13 | 1705319400000 | 1970 – 2286 (×1000) |
| Microseconds (μs) | 16 | 1705319400000000 | Sub-second precision |
| Nanoseconds (ns) | 19 | 1705319400000000000 | Used by Go, Rust, Linux kernel |
Search or browse the timestamp examples and identify whether your source counts seconds or milliseconds. Use the conversion snippet below to check a known Unix seconds value: JavaScript Date expects milliseconds, so the multiplication is essential. Compare the ISO result in UTC before formatting it for a user's timezone. A local display can change the clock reading without changing the represented instant.
Store an unambiguous instant and apply display formatting at the boundary where people read it. Preserve precision deliberately when handling microseconds or nanoseconds; a floating point number can lose small differences at large magnitudes. Unix time does not count leap seconds. This reference supplies examples rather than running your database queries or inspecting an API, so verify each receiving system's units and supported range.
const ts = 1700000000;
const date = new Date(ts * 1000);
date.toUTCString(); // "Tue, 14 Nov 2023 22:13:20 GMT"
date.toLocaleString(); // Depends on user's local time zone
date.toISOString(); // "2023-11-14T22:13:20.000Z"
-- Current timestamp
SELECT EXTRACT(EPOCH FROM NOW());
-- Timestamp to date
SELECT TO_TIMESTAMP(1700000000);
-- Date to timestamp
SELECT EXTRACT(EPOCH FROM '2023-11-14'::timestamp);
A Unix timestamp (also called epoch time) is the number of seconds elapsed since 00:00:00 UTC on January 1, 1970, not counting leap seconds. It is a single integer that unambiguously identifies any moment in time, independent of timezone.
Traditional Unix timestamps count whole seconds. Modern languages and APIs (JavaScript Date.now(), Java System.currentTimeMillis()) use milliseconds — 1000× larger — for sub-second precision. When interoperating, always check the magnitude: a 10-digit number is seconds, a 13-digit number is milliseconds.
32-bit signed integers can represent timestamps up to 2,147,483,647, which corresponds to 03:14:07 UTC on January 19, 2038. After that moment 32-bit systems will overflow to negative values. 64-bit systems can safely represent dates well beyond the year 292 billion.
In JavaScript: new Date(ts * 1000).toISOString(). In Python: datetime.fromtimestamp(ts, tz=timezone.utc).isoformat(). In SQL (PostgreSQL): to_timestamp(ts). ISO 8601 format is YYYY-MM-DDTHH:MM:SSZ for UTC, e.g. 2024-01-15T12:30:00Z.
A Unix timestamp identifies an instant relative to the epoch; it does not store an original timezone label. A local formatted date can show a different clock time for the same instant. Keep timezone information separately when your application needs the original civil-time context, and confirm seconds versus milliseconds at API boundaries.