Unix Timestamp Converter

Convert between Unix timestamps and human-readable dates.

Code & String Helpers

Convert Unix Timestamps Online: Epoch Seconds & Milliseconds to Human Dates

You are inspecting a JWT authentication token, checking database records in MongoDB or PostgreSQL, or debugging an API error log. You find a date field, but instead of a recognizable calendar date like "September 26, 2026", you see a mysterious number: 1790412800.

That number is a Unix epoch timestamp—the fundamental clock of the computing world. Unix time tracks the passage of time as the total number of seconds elapsed since 00:00:00 UTC on January 1, 1970 (the Unix epoch).

Computers love epoch numbers because performing date math—subtracting two integers to find a session duration—is lightning fast and immune to confusing calendar daylight saving changes. But humans cannot read epoch timestamps without converting them. Our free Unix Timestamp Converter translates epoch seconds and milliseconds into UTC, ISO 8601, and your local time zone instantly.

Seconds vs. Milliseconds: The 10 vs. 13 Digit Rule

The single most common bug when working with epoch timestamps is confusing seconds with milliseconds:

10 Digits (Seconds)

Used by: Python, PHP, Linux, JWT

Example: 1790412800

Standard Unix time in POSIX systems, MySQL UNIX_TIMESTAMP(), and JWT token claims (exp, iat). Tracks time down to the nearest second.

13 Digits (Milliseconds)

Used by: JavaScript & Java

Example: 1790412800000

JavaScript's Date.now() and Java's System.currentTimeMillis() measure time in milliseconds. Passing a 10-digit number to JavaScript returns a date in January 1970 because it interprets it as milliseconds!

The Year 2038 Problem (Y2K38): Why It Matters

In early 32-bit operating systems, Unix time was stored as a signed 32-bit integer. The maximum positive number that a signed 32-bit integer can hold is 2,147,483,647.

Maximum 32-bit timestamp: 2,147,483,647

Exact date: Tuesday, January 19, 2038 at 03:14:07 UTC

Next second (overflow): -2,147,483,648 → rolls back to December 13, 1901!

Known as the Y2K38 bug, older embedded systems and legacy 32-bit databases risk severe time malfunction. Modern 64-bit systems have upgraded to 64-bit timestamps, extending safe time calculations for another 292 billion years.

How Developers Work with Timestamps in Code

JavaScript

const currentSeconds = Math.floor(Date.now() / 1000); // 10 digits
const dateFromSeconds = new Date(1790412800 * 1000);

Python

import time
from datetime import datetime
current_epoch = int(time.time())
readable_date = datetime.fromtimestamp(1790412800)

Frequently Asked Questions

Do Unix timestamps account for leap seconds?

By POSIX definition, Unix time ignores leap seconds. Every standard Unix day is defined as having exactly 86,400 seconds. When an official leap second is inserted by astronomical authorities, Unix clocks repeat or smear a second to maintain synchronization.

Can a Unix timestamp be negative?

Yes! Negative epoch numbers represent dates before January 1, 1970. For example, the timestamp -141829200 represents the Apollo 11 moon landing on July 20, 1969.

Why does the date change when I view it on a different computer?

A Unix timestamp is always based on universal UTC time. When displayed in "Local Time", your browser automatically converts the UTC timestamp into your computer's current geographic time zone (such as EST, PST, or IST).