What is a Unix Timestamp? Complete Guide to Epoch Time

What is a Unix timestamp?

A Unix timestamp (also called epoch time, Unix time, or POSIX time) is the number of seconds that have elapsed since January 1, 1970, at 00:00:00 Coordinated Universal Time (UTC). This reference point is called the Unix Epoch.

For example:

• 0 → January 1, 1970, 00:00:00 UTC
• 86400 → January 2, 1970, 00:00:00 UTC (exactly one day later)
• 1741478400 → March 9, 2025, 08:00:00 UTC

The key insight is that a Unix timestamp is completely timezone-independent. The number 1741478400 represents the same instant everywhere on Earth — what changes is how that instant is expressed in local time. In New York it is March 9, 2025, 03:00:00 EST. In Tokyo it is March 9, 2025, 17:00:00 JST. The timestamp itself never changes.

Why January 1, 1970?

The date was chosen by the developers of the original Unix operating system in the early 1970s as a convenient, recent starting point. There is no deep mathematical or historical significance — it was simply practical. They needed a recent date that would make timestamps small enough to fit in 32-bit integers for the foreseeable future.

Seconds vs. milliseconds — and how to tell them apart

Over time, two variants of Unix timestamps became common:

• Seconds (10 digits): The original Unix format. Example: 1741478400. Used by most operating systems, POSIX APIs, databases, and server-side languages.
• Milliseconds (13 digits): Popularised by JavaScript's Date.now() and Java's System.currentTimeMillis(). Example: 1741478400000. Common in web APIs and front-end code.

A simple rule of thumb: if the number has 10 digits, it's in seconds. If it has 13 digits, it's in milliseconds. Our converter auto-detects this based on the digit count.

Confusing the two is a very common bug. Using a millisecond timestamp where seconds are expected produces dates decades in the future (around year 56,000). Using a seconds timestamp where milliseconds are expected produces dates in early January 1970.

How to get the current Unix timestamp

Language	Seconds	Milliseconds
JavaScript	Math.floor(Date.now()/1000)	Date.now()
Python	int(time.time())	int(time.time()*1000)
PHP	time()	round(microtime(true)*1000)
Java	Instant.now().getEpochSecond()	System.currentTimeMillis()
Go	time.Now().Unix()	time.Now().UnixMilli()
Bash	date +%s	date +%s%3N
SQL (MySQL)	UNIX_TIMESTAMP()	UNIX_TIMESTAMP()*1000

The Year 2038 problem

On systems that store timestamps as a 32-bit signed integer, the maximum value is 2,147,483,647 — which corresponds to January 19, 2038, at 03:14:07 UTC. One second after that, the counter overflows to -2,147,483,648, which represents December 13, 1901 — a date far in the past.

This is known as the "Year 2038 problem" (similar in concept to Y2K). Modern 64-bit systems are unaffected because a 64-bit signed integer can hold timestamps up to the year 292,277,026,596 — effectively no limit in practice.

Most modern operating systems and databases have already migrated to 64-bit timestamps, but some embedded systems, legacy databases, and old C code may still use 32-bit integers.

Timezones and Unix timestamps

A common misconception is that you need to know the timezone to use a Unix timestamp. You do not. The timestamp itself is always in UTC. Timezones only come into play when you convert the timestamp to a human-readable string for display purposes.

When storing timestamps in databases or passing them through APIs, always use Unix timestamps or ISO 8601 strings with the UTC offset (Z suffix). Never store bare "local time" strings — they are ambiguous during daylight saving time transitions and across timezones.

ISO 8601 and Unix timestamps

ISO 8601 is the international standard for date/time strings. Example: 2025-03-09T08:00:00.000Z. The T separates date from time, and the trailing Z means UTC. ISO 8601 strings are human-readable and sortable lexicographically, making them a good choice for log files and APIs. Unix timestamps are more compact and better for arithmetic (comparing durations, sorting, etc.).

Frequently asked questions

What is the Unix timestamp right now?

Check the live timestamp at the top of our Timestamp Converter. In JavaScript: Math.floor(Date.now()/1000). In Python: int(time.time()).

Why does the Unix Epoch start on January 1, 1970?

It was chosen by the original Unix developers as a convenient recent starting point. No deep significance — just practical for fitting timestamps in 32-bit integers while leaving room for future dates.

What is the maximum Unix timestamp?

On 32-bit systems: 2,147,483,647 (January 19, 2038). On 64-bit systems: 9,223,372,036,854,775,807 (year ~292 billion) — effectively unlimited.

Related tools

• UUID Generator — Generate random unique identifiers
• Regex Tester — Test and debug regular expressions
• URL Encoder / Decoder — Encode and decode URLs