Unix timestamp converter

Current Unix time

The clock reads your device clock once a second. Seconds are what most APIs and databases store; milliseconds are what JavaScript, Java and many web APIs return. Both numbers above name the same moment.

Timestamp to date

Auto-detect reads the size of the number: under 100 billion is seconds, under 100 trillion is milliseconds, under 100 quadrillion is microseconds, and anything larger is nanoseconds. A 10-digit timestamp from today is seconds; a 13-digit one is milliseconds. If the number could be either, pick the unit by hand.

Date to timestamp

The date you pick is read as a wall-clock time in the timezone you choose. Daylight saving time comes from that zone's own rules, so noon in New York converts to 16:00 UTC in June and 17:00 UTC in January.

Convert a batch

Each line is read on its own: the first number of 8 to 19 digits is treated as the timestamp, and the rest of the line is ignored. That is the shape of a log line, a database dump, or a column copied out of a spreadsheet. Lines with no such number are reported, not silently dropped.

What is a Unix timestamp?

A Unix timestamp, also called Unix time, POSIX time, or epoch time, is the number of seconds that have passed since January 1, 1970, at 00:00:00 UTC. That fixed starting point is the Unix epoch. The timestamp 1716192000 names May 20, 2024, at 08:00:00 UTC, and the same number names the same moment in every timezone, because the number itself carries no timezone at all.

Systems store time this way because one integer is easy to compare, sort, and subtract. The difference between two timestamps is the number of seconds between the two moments, with no calendar math in between. Dates, timezones, and daylight saving time only appear when the number is shown to a person, which is what this page does.

Unix time ignores leap seconds: every day is treated as exactly 86,400 seconds. That keeps the arithmetic clean, and it means Unix time now sits 27 seconds behind the astronomical time kept by leap seconds. A timestamp is also not a date format for humans. It needs a converter, a library, or a line of code before anyone can read it, and the code section below shows the usual forms.

Seconds, milliseconds, microseconds, nanoseconds

Four units are in common use, and mixing them up is the most common timestamp bug: a 10-digit timestamp read as milliseconds lands in 1970, and a 13-digit one read as seconds lands in the year 50000. The digit count gives the unit away.

When a value arrives without a unit, check the digits first, then check the source. JavaScript returns milliseconds, Python returns seconds as a float, and Go has a function for each. If the number is 10 digits, it is seconds; if it is 13, it is milliseconds. This page detects the unit from the size of the number and labels which one it used, so a wrong guess is visible at once.

Convert a timestamp in code

Use the standard library in production. The snippets below show the shape of the work in each language, so a conversion can be checked by hand. The JavaScript and Python versions were run while this page was written.

JavaScript

// Unix seconds to a Date object
const seconds = 1716192000;
const date = new Date(seconds * 1000);
date.toISOString(); // "2024-05-20T08:00:00.000Z"

// Current Unix timestamp in seconds
const nowSeconds = Math.floor(Date.now() / 1000);
// Date object back to Unix seconds
const backToSeconds = Math.floor(date.getTime() / 1000);

Python

from datetime import datetime, timezone
timestamp = 1716192000
dt = datetime.fromtimestamp(timestamp, tz=timezone.utc)
dt.isoformat()  # "2024-05-20T08:00:00+00:00"
# Current Unix timestamp in seconds
import time
now_seconds = int(time.time())

Go

import "time"
// Unix seconds to a time value, in UTC
t := time.Unix(1716192000, 0).UTC()
// Current Unix timestamp in seconds
now := time.Now().Unix()
// Current Unix timestamp in nanoseconds
nowNano := time.Now().UnixNano()

SQL and shell

-- PostgreSQL
SELECT to_timestamp(1716192000); -- 2024-05-20 08:00:00+00
-- MySQL
SELECT FROM_UNIXTIME(1716192000); -- 2024-05-20 08:00:00
# Shell, GNU date
date -u -d @1716192000 # Mon May 20 08:00:00 UTC 2024

The Go functions are the ones listed in the Go time package documentation, and the Python call is the documented datetime.fromtimestamp form with an explicit UTC timezone. The SQL forms are the documented PostgreSQL to_timestamp and MySQL FROM_UNIXTIME functions.

Notable timestamps

A few numbers are worth recognising on sight, because they turn up in tests, in documentation, and in old data.

The year 2038 problem

Old systems that store Unix timestamps as signed 32-bit integers hold at most 2,147,483,647. That number is reached on January 19, 2038, at 03:14:07 UTC. One second later the counter wraps to a negative number, which the system reads as December 13, 1901. 64-bit systems are not affected: Linux moved to a 64-bit time type in 2020 for 32-bit architectures, and PostgreSQL, MySQL 8, Python 3, Node.js, Go, and Java 8 and later all use 64-bit integers internally. The risk that remains sits in old embedded systems and file formats that still store 32-bit times.

Sources

Mozilla Developer Network, Date: JavaScript Date stores milliseconds since the epoch, and Date.now() returns the current time in milliseconds.

Wikipedia, Unix time: the epoch definition, the leap second count of 27, and the year 2038 problem.

Internet Engineering Task Force, RFC 3339: Date and Time on the Internet: the ISO 8601 profile used for the timestamp format shown on this page.

Go project, time package: time.Unix, UnixNano, and the nanosecond precision of Go time values.

Python Software Foundation, datetime: datetime.fromtimestamp with an explicit UTC timezone, and time.time() returning seconds as a float.

More tools for builders

• llms.txt Checker
• Claude Skill Validator
• UUID v7 Generator
• ULID Generator
• Robots.txt Generator
• JWT Decoder
• Markdown Table Generator
• Chmod Calculator
• Cron Expression Generator