Unix Timestamp Converter

Convert Unix timestamps to dates and back. Live current timestamp included.

FreeLive timestampTimezone support
Current Unix timestamp
Local time
UTC time

Timestamp → Date

Date → Timestamp

Advertisement

What is a Unix timestamp?

Seconds since epoch

A Unix timestamp counts seconds elapsed since January 1, 1970 00:00:00 UTC. It's the universal standard for representing time in programming across all languages and platforms.

Seconds vs milliseconds

JavaScript uses milliseconds (13-digit timestamps). Unix and most server languages use seconds (10-digit). This tool handles both automatically.

Always UTC

Unix timestamps are always in UTC. This tool shows both local and UTC output so you can see both representations.

Unix Timestamps — The Universal Language of Time in Programming

Every programming language, database, and operating system understands Unix timestamps. They are the single most universal way to represent a moment in time in software — a simple integer that counts seconds since January 1, 1970 at midnight UTC. No timezone ambiguity, no locale formatting, no parsing complexity. Just a number.

Why January 1, 1970?

The Unix operating system was developed at Bell Labs in the late 1960s. When the developers needed a reference point for time, they chose January 1, 1970 as a round number close to the system's creation date. This moment — called the Unix epoch — became the universal starting point. Every Unix timestamp counts seconds forward (or backward, for negative values) from this moment.

Seconds vs milliseconds — the source of many bugs

Unix traditionally uses seconds. JavaScript uses milliseconds. This single difference causes real bugs — passing a JavaScript timestamp (13 digits) to a Unix-expecting function produces a date in the year 55,000+. Always check: 10-digit timestamp = seconds, 13-digit = milliseconds. To convert: divide ms by 1000, multiply seconds by 1000.

The Year 2038 problem

On 32-bit systems, timestamps are stored as signed 32-bit integers with a maximum of 2,147,483,647 — which corresponds to January 19, 2038. After this date, 32-bit systems overflow. Modern 64-bit systems can represent timestamps hundreds of billions of years into the future. Most systems have migrated, but embedded devices and legacy industrial software remain at risk.

Frequently asked questions

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. It's the universal standard for representing moments in time in software, used by databases, APIs, logs, and virtually every programming language.
How do I convert a Unix timestamp to a readable date?
Enter your Unix timestamp in the "Timestamp → Date" box and click Convert. The tool shows the local time in your browser's timezone, the UTC time, and the ISO 8601 format. It also automatically detects whether your timestamp is in seconds (10 digits) or milliseconds (13 digits).
What is the difference between Unix timestamps in seconds and milliseconds?
Traditional Unix timestamps are in seconds and have 10 digits (e.g. 1700000000). JavaScript and some modern APIs use milliseconds and have 13 digits (e.g. 1700000000000). To convert between them: multiply seconds by 1000 to get milliseconds, or divide milliseconds by 1000 to get seconds.
What is the Unix epoch?
The Unix epoch is the point in time from which Unix timestamps are counted: January 1, 1970, 00:00:00 UTC. Timestamp 0 equals exactly that moment. All Unix timestamps count seconds forward (or backward for negative values) from this point.
How do I get the current Unix timestamp in code?
The live timestamp at the top of this page updates every second. In code: JavaScript: Math.floor(Date.now() / 1000) — Python: import time; int(time.time()) — PHP: time() — Go: time.Now().Unix() — SQL: UNIX_TIMESTAMP() (MySQL) or EXTRACT(EPOCH FROM NOW()) (PostgreSQL).
What is the Year 2038 problem?
On 32-bit systems, Unix timestamps are stored as a signed 32-bit integer with a maximum value of 2,147,483,647 — which corresponds to January 19, 2038. After this date, 32-bit systems will overflow. Modern 64-bit systems don't have this issue and can store timestamps hundreds of billions of years into the future.