What Is a Unix Timestamp?

A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have elapsed since midnight UTC on January 1, 1970 — the Unix Epoch. For example:

• 0 = 1970-01-01 00:00:00 UTC
• 1000000000 = 2001-09-09 01:46:40 UTC
• 1700000000 = 2023-09-14 22:13:20 UTC

Unix timestamps are timezone-agnostic — they always refer to UTC. Converting to a local time is a display-layer concern, handled by the system's timezone configuration.

Why Do Timestamps Start in 1970?

Unix was developed at Bell Labs in the late 1960s. When the developers needed a reference point for time, they chose the start of 1970 — a recent, round number. There was no special technical significance to the date; it was simply convenient. Because Unix became the foundation of most operating systems and programming languages, the 1970 epoch became a universal standard.

Seconds vs Milliseconds

The Unix standard uses seconds, but many modern APIs and programming environments (including JavaScript's Date object) use milliseconds since the epoch. A millisecond timestamp is 1,000× larger than a second timestamp.

Format	Example	Note
Seconds (Unix)	1700000000	10 digits since 2001
Milliseconds (JS)	1700000000000	13 digits since 2001

If your timestamp has 13 digits, it is almost certainly milliseconds. Divide by 1000 to get seconds.

How to Convert in Code

JavaScript:

// Timestamp to date
new Date(1700000000 * 1000).toISOString(); // '2023-09-14T22:13:20.000Z'

// Current timestamp
Math.floor(Date.now() / 1000);

Python:

from datetime import datetime, timezone

# Timestamp to date
datetime.fromtimestamp(1700000000, tz=timezone.utc)

# Current timestamp
import time; int(time.time())

The Y2K38 Problem

On January 19, 2038 at 03:14:07 UTC, 32-bit signed integers used to store Unix timestamps will overflow — wrapping from the maximum positive value (2,147,483,647) to the maximum negative value, representing a date in 1901. This is the Y2K38 (or Year 2038) problem.

Systems using 64-bit integers do not have this problem — a 64-bit timestamp can represent dates billions of years in the future. Most modern operating systems and languages already use 64-bit time, but legacy embedded systems and databases using 32-bit timestamps must be audited.

Converting Unix Timestamps Online

Use the ToolsBox Unix Timestamp Converter to convert any timestamp to a human-readable date and back again. Enter a timestamp to see the UTC and local datetime, or enter a date to get the corresponding timestamp. No signup required.

Frequently Asked Questions

What is a Unix timestamp?

A Unix timestamp is the number of seconds since January 1, 1970, 00:00:00 UTC (the Unix Epoch). It is timezone-agnostic, always referring to UTC. Converting to local time is a display concern handled by the application or OS.

Why does Unix time start in 1970?

When Unix was developed in the late 1960s, the developers chose the start of 1970 as a convenient, recent round number for the epoch. There was no special significance — it became a universal standard because Unix became the foundation of most operating systems.

What is the Y2K38 problem?

On January 19, 2038, 32-bit signed integers storing Unix timestamps will overflow, wrapping to a negative value representing a date in 1901. Systems using 64-bit timestamps are unaffected. Legacy embedded systems and databases using 32-bit time must be migrated before that date.

How do I convert a Unix timestamp to a date?

JavaScript: new Date(timestamp * 1000).toISOString(). Python: datetime.fromtimestamp(timestamp, tz=timezone.utc). If your timestamp has 13 digits, it is milliseconds — divide by 1000 first. Use the ToolsBox Unix Timestamp Converter for quick lookups without coding.