Epoch Converter – Unix Timestamp Converter

How to use the epoch converter

• Current Unix time: the clock at the top ticks every second in seconds and milliseconds. Press Copy to grab the value, or Pause to freeze it.
• Timestamp to date: paste a Unix timestamp. The converter detects whether it is in seconds, milliseconds, microseconds or nanoseconds, and shows the date in UTC, your own time zone, ISO 8601, RFC 2822 and relative time ("3 hours ago"). Add any other time zone, such as Asia/Tokyo, to compare.
• Date to timestamp: pick a date, a time and a time zone (local, UTC or any IANA zone) to get the epoch time in seconds and milliseconds.
• Batch: paste a list of timestamps or dates, one per line, and download the results as CSV.

What is Unix time (epoch time)?

Unix time is the number of seconds since the Unix epoch, midnight UTC on 1 January 1970. It is a single integer with no time zone, so computers use it to store and compare moments in time: log files, databases, APIs, file systems and tokens. It is also called epoch time, POSIX time or simply a Unix timestamp.

Every day in Unix time is exactly 86,400 seconds long. Leap seconds are ignored, which keeps the arithmetic simple: add 3,600 for an hour, 86,400 for a day, 604,800 for a week.

Convert epoch to date

To convert a Unix timestamp to a date by hand, split it into whole days and the seconds left over:

1. Divide by 86,400: 1,700,000,000 ÷ 86,400 = 19,675 whole days, with 80,000 seconds left over.
2. Count 19,675 days forward from 1 January 1970: that lands on 14 November 2023.
3. Turn the leftover seconds into a time: 80,000 s = 22 h 13 min 20 s, so 22:13:20 UTC.
4. Apply a time zone offset if you need local time: New York is UTC−05:00 in November, which gives 17:13:20.

The converter does all of this, including daylight saving time, for any zone. Some useful reference points:

Convert date to Unix timestamp

Going the other way, the same clock time gives a different timestamp in every time zone, so always say which zone a date is in. Midnight UTC on 25 September 2026 is 1790294400. 9:00 AM that morning in New York (UTC−04:00) is 1790341200, and 9:00 AM in India (Asia/Kolkata, UTC+05:30) is 1790307000.

Daylight saving time adds two traps. On 8 March 2026 New York skipped from 2:00 to 3:00 AM, so 2:30 AM never happened; the converter moves it forward to 3:30 AM EDT (1772955000) and tells you. On 1 November 2026 the clocks went back and 1:30 AM happened twice: first as EDT (1793511000), then an hour later as EST (1793514600). The converter uses the first and shows the second.

Seconds vs milliseconds

Different languages count in different units, and mixing them up is the most common timestamp bug: a millisecond value read as seconds lands tens of thousands of years in the future. The number of digits tells you which one you have:

Auto-detect reads a number as seconds below 100,000,000,000 (the largest is 5138-11-16, far beyond any real date), then milliseconds, microseconds and nanoseconds at each further factor of 1,000. The one blind spot: millisecond timestamps from before 1973-03-03 are small enough to look like seconds, so choose the unit yourself for early-1970s data. Micro- and nanosecond inputs keep every digit, so the ISO 8601 output shows the full fraction, e.g. 2023-11-14T22:13:20.123456789Z.

The year 2038 problem

Older software stores Unix time in a signed 32-bit integer, whose largest value is 2³¹ − 1 = 2147483647: 03:14:07 UTC on 19 January 2038. One second later the counter overflows to -2147483648, which reads as 1901-12-13. Linux, macOS, modern databases and languages now use 64-bit time, but embedded devices, old file formats and 32-bit builds can still break. The converter flags any timestamp outside the 32-bit range.

Negative timestamps work the same way in reverse: -1 is 23:59:59 UTC on 31 December 1969. The far limit is set by JavaScript, which handles dates up to the year 275760 and back to 271821 BC; anything beyond that gets a clear error instead of a wrong date.

Get the current timestamp in JavaScript, Python, SQL and Bash

JavaScript

Math.floor(Date.now() / 1000)               // seconds
Date.now()                                   // milliseconds
new Date(1700000000 * 1000).toISOString()    // '2023-11-14T22:13:20.000Z'
Date.parse('2026-09-25T00:00:00Z') / 1000    // 1790294400

Python

import time
from datetime import datetime, timezone

int(time.time())                 # seconds
time.time_ns() // 1_000_000      # milliseconds
datetime.fromtimestamp(1700000000, tz=timezone.utc).isoformat()
# '2023-11-14T22:13:20+00:00'
int(datetime(2026, 9, 25, tzinfo=timezone.utc).timestamp())
# 1790294400

SQL

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM now())::bigint;
SELECT to_timestamp(1700000000);                -- 2023-11-14 22:13:20+00 (UTC session)

-- MySQL (results are in the session time zone)
SELECT UNIX_TIMESTAMP();
SELECT FROM_UNIXTIME(1700000000);

-- SQLite
SELECT unixepoch();                             -- 3.38+, or strftime('%s', 'now')
SELECT datetime(1700000000, 'unixepoch');       -- 2023-11-14 22:13:20

Bash

date +%s                  # seconds
date +%s%3N               # milliseconds (GNU date on Linux)
date -u -d @1700000000    # Linux: Tue Nov 14 22:13:20 UTC 2023
date -u -r 1700000000     # macOS and BSD

Other developer and time tools

• JWT decoder: the exp, iat and nbf claims in a JSON Web Token are Unix timestamps in seconds. Decode a token to see when it expires.
• JSON formatter and validator: pretty-print an API response to find the timestamp fields, then paste them into the batch converter.
• Time calculator: add or subtract hours, minutes and seconds, or find the time before or after a start time.

Frequently asked questions