What is a Unix timestamp?

A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have elapsed since January 1, 1970 at 00:00:00 UTC, not counting leap seconds. It provides a single universal integer that represents any point in time, independent of timezone or calendar format. Unix timestamps are used in virtually every programming language, database, and operating system.

What is the difference between seconds and milliseconds timestamps?

Traditional Unix timestamps count seconds. JavaScript's Date.now() and many modern APIs return milliseconds (multiply seconds by 1,000). A 10-digit number is typically seconds (e.g., 1700000000); a 13-digit number is typically milliseconds (e.g., 1700000000000). This tool auto-detects which format you entered and shows both conversions.

What is UTC and why does it matter?

UTC (Coordinated Universal Time) is the primary time standard used globally. It has no daylight saving time and does not change with location. When you store or transmit timestamps, always use UTC to avoid timezone confusion. The "local time" display on this tool shows the timestamp converted to your browser's local timezone.

What is the maximum value a Unix timestamp can hold?

A 32-bit signed integer can hold Unix timestamps up to January 19, 2038 (the "Year 2038 problem"). Modern systems use 64-bit integers, which can represent dates billions of years into the future and past. JavaScript uses 64-bit floats, supporting dates from ±8,640,000,000,000,000 milliseconds (about ±273,000 years).

How do I get the current Unix timestamp in various languages?

JavaScript: Date.now() (ms) or Math.floor(Date.now()/1000) (s). Python: import time; time.time(). Unix shell: date +%s. SQL: UNIX_TIMESTAMP() (MySQL) or EXTRACT(EPOCH FROM NOW()) (PostgreSQL). Go: time.Now().Unix(). Use the "Use Now" button in this tool to see the current timestamp instantly.

Does Unix time account for leap seconds?

No. POSIX defines a day as exactly 86,400 seconds, so Unix time deliberately ignores leap seconds and is not a true count of elapsed SI seconds since 1970. During a positive leap second the same timestamp value is effectively repeated, which is why providers like Google and AWS "smear" the extra second gradually across a 24-hour window instead of letting clocks step backwards. If you need leap-second-accurate timing, use TAI or GPS time rather than Unix time.

Unix Timestamp Converter - Epoch to Date

Convert Unix timestamps to human-readable dates and vice versa. Free epoch converter - supports milliseconds, UTC, and local timezone.

🔒 Your text stays in your browser - nothing is sent to our servers

Unix Timestamp → Human Date

Date & Time → Unix Timestamp

Date

Time (optional)

How to Use

Three steps to get started

Timestamp to date

Paste a Unix timestamp (seconds or milliseconds) into the top panel. The tool auto-detects the format and shows the full date in UTC, local time, ISO 8601, and relative format.

Date to timestamp

Use the bottom panel to pick a date and time, then instantly get the Unix timestamp in both seconds and milliseconds.

Use "Now" shortcut

Click "Use Now" to instantly load the current Unix timestamp and see all its representations.

About This Tool

Unix timestamps: the universal language of time

A Unix timestamp is a single integer counting the number of seconds elapsed since the Unix epoch - 00:00:00 UTC on 1 January 1970 - excluding leap seconds. It is also called epoch time, POSIX time, or simply epoch, and it is standardized in POSIX (IEEE Std 1003.1) as time_t. Rather than storing a date as a human-readable string, which varies by locale, calendar, and timezone, systems store this one number and format it only at the moment of display.

The advantages are mechanical: integers sort correctly by default, arithmetic is trivial (add 86400 for tomorrow, subtract two values for elapsed seconds), the value is timezone-independent, and every language and database can exchange it without agreeing on a format. Some reference points worth recognising: 0 is the epoch itself,1000000000 was 9 September 2001, and 1700000000 was 14 November 2023.

Seconds, milliseconds, and the digit-count rule

The single most common bug in timestamp handling is a factor-of-1,000 unit mismatch. C, Python's time.time() (as an integer), Go's Unix(), PostgreSQL's EXTRACT(EPOCH …) and JWT exp claims all useseconds. JavaScript's Date.now(), Java'sSystem.currentTimeMillis(), and most JSON APIs usemilliseconds. The quick heuristic: a 10-digit value is seconds and a 13-digit value is milliseconds - anything else, and you are probably looking at microseconds (16 digits) or a bug. Feeding seconds tonew Date() silently yields a date in January 1970, which is the classic symptom.

Common developer scenarios

API debugging - log files and API responses often return timestamps; convert to check if they are correct
JWT expiry - JWT tokens contain an exp field as a Unix timestamp; check if a token has expired
Database records - convert created_at or updated_at Unix fields to readable dates
Scheduling - calculate future cron trigger times or cache TTL expirations
Relative time - check how long ago an event happened ("3 hours ago", "yesterday")

Two pitfalls are worth knowing about. Unix time ignores leap seconds by definition, so it is not a true count of elapsed SI seconds; during a leap second the same timestamp value is repeated, which is why Google and AWS "smear" the extra second across a day rather than let clocks repeat. And the Year 2038 problemis real for anything still using a signed 32-bit time_t: that counter overflows at 03:14:07 UTC on 19 January 2038 and wraps to December 1901. 64-bit systems are unaffected for roughly 292 billion years, and JavaScript's 64-bit floatDate covers ±8,640,000,000,000,000 ms - about ±273,000 years - but embedded firmware and old database columns remain exposed.

All conversions are performed in your browser using the JavaScript Date API. No data is sent to any server.

FAQ

Frequently Asked Questions

Related Tools