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 is a universal, timezone-independent way to represent any moment in time used across virtually all programming languages, databases, and APIs.

How do I convert a Unix timestamp to a human-readable date?

Enter the timestamp in the converter above. It shows the equivalent date and time in UTC, ISO 8601, your browser's local time, and milliseconds. For example, 1700000000 = November 14, 2023, 22:13:20 UTC. In code: new Date(1700000000 * 1000) in JavaScript, or datetime.utcfromtimestamp(1700000000) in Python.

What is the difference between Unix seconds and milliseconds?

Unix timestamps are traditionally in seconds (10 digits for modern dates, e.g. 1700000000). JavaScript's Date.now() and many web APIs return milliseconds (13 digits, e.g. 1700000000000). The converter auto-detects which unit you're using based on digit count: 10 digits = seconds, 13 digits = milliseconds.

What is the Unix epoch and why January 1, 1970?

The Unix epoch (January 1, 1970 00:00:00 UTC) was chosen when Unix was being developed at Bell Labs in the late 1960s. It was a recent, round date that fit within the 32-bit integer range used by early systems. Negative timestamps represent dates before 1970 (e.g. -1 = December 31, 1969 23:59:59 UTC).

What is the Year 2038 problem?

The maximum 32-bit signed integer is 2,147,483,647, which corresponds to January 19, 2038 at 03:14:07 UTC. On systems storing timestamps as 32-bit signed integers, adding one second would overflow to a large negative number, causing dates to jump to 1901. Modern 64-bit systems are not affected.

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

JavaScript: Math.floor(Date.now() / 1000) or Date.now() for milliseconds. Python: import time; int(time.time()). PHP: time(). Go: time.Now().Unix(). Bash/shell: date +%s. SQL (PostgreSQL): EXTRACT(EPOCH FROM NOW()). SQL (MySQL): UNIX_TIMESTAMP().

What is ISO 8601 and how does it relate to Unix time?

ISO 8601 is an international standard for representing dates and times as strings (e.g. 2023-11-14T22:13:20Z). The 'Z' suffix means UTC. While Unix timestamps are integers (machine-friendly), ISO 8601 strings are human-readable and sortable. Both represent the same moment — the converter shows both for any timestamp.

Can Unix timestamps represent dates before 1970?

Yes. Timestamps before the Unix epoch are negative integers. January 1, 1900 00:00:00 UTC = -2208988800. Most modern systems and languages support negative timestamps, though 32-bit signed systems are limited to dates after December 13, 1901.

Why do some APIs use milliseconds instead of seconds?

Millisecond precision is useful for applications where sub-second timing matters — logging, performance monitoring, financial transactions, animations. JavaScript popularized millisecond timestamps through Date.getTime(). When integrating APIs, always check the documentation to avoid off-by-1000 errors.

What is the largest Unix timestamp a 64-bit system can represent?

A 64-bit signed integer can hold up to 9,223,372,036,854,775,807 seconds, corresponding to approximately year 292,277,026,596. In practice, no software or hardware limitation from Unix timestamps will affect humans within any foreseeable future.

Unix Timestamp Converter

Convert between Unix timestamps and human-readable dates.

Current Unix Timestamp

1773828972

Unix Timestamp → Date

Unix Timestamp (seconds)

UTCWed, 18 Mar 2026 10:16:12 GMT

ISO 86012026-03-18T10:16:12.000Z

LocalMarch 18, 2026 10:16:12

Milliseconds1773828972000

Date → Unix Timestamp

Date & Time

Unix Timestamp1773828972

Related Tools

Roman Numerals Leap Year

What is Unix Time?

Unix time (also called epoch time or POSIX time) counts the number of seconds elapsed since January 1, 1970, 00:00:00 UTC — a moment known as the Unix epoch. It was standardized alongside the Unix operating system at Bell Labs and has since become the universal time representation in software.

Because Unix timestamps are timezone-agnostic integers, they are ideal for storing and transmitting dates in APIs, databases, and logs. Converting to a human-readable date only happens at display time, using the viewer's local timezone — which is why the same timestamp shows a different clock time in New York and Tokyo.

Reference Timestamps

Event	UTC Date	Timestamp (s)
Unix Epoch	Jan 1, 1970 00:00:00 UTC	0
Y2K	Jan 1, 2000 00:00:00 UTC	946684800
iPhone launch	Jan 9, 2007 18:00:00 UTC	1168365600
1 billion seconds	Sep 9, 2001 01:46:40 UTC	1000000000
1.5 billion seconds	Jul 14, 2017 02:40:00 UTC	1500000000
1.7 billion seconds	Nov 14, 2023 22:13:20 UTC	1700000000
2038 overflow (32-bit)	Jan 19, 2038 03:14:07 UTC	2147483647

Get the Current Timestamp in Code

JavaScript

Math.floor(Date.now() / 1000)

Python

import time
int(time.time())

PHP

time()

time.Now().Unix()

Bash

date +%s

PostgreSQL

EXTRACT(EPOCH FROM NOW())

The Year 2038 Problem

The maximum 32-bit signed integer (2,147,483,647) corresponds to January 19, 2038 at 03:14:07 UTC. Systems storing timestamps as 32-bit integers will overflow at that moment, potentially jumping to 1901. Modern 64-bit systems are unaffected — they can represent dates up to year ~292 billion. If you maintain legacy C/embedded code using time_t as a 32-bit integer, migration to 64-bit is recommended before 2038.