IT Tool

Unix Timestamp Converter

Convert a Unix / epoch timestamp to a human-readable date and back. Auto-detects seconds vs milliseconds and shows local, UTC, ISO 8601, and live relative time.

Instant 100% Client-Side No Login
PROCESSINGLOCAL
LIMITNONE
PRIVACYBROWSER-ONLY
Current Unix Time:

Epoch → Date

Date → Epoch

Unix time is one integer counting seconds from a fixed instant

Unix time, also called POSIX time or epoch time, is a single integer: the count of seconds elapsed since 00:00:00 UTC on 1 January 1970, the moment the standard calls the epoch. That anchor was chosen in the early 1970s by the team building Unix at Bell Labs, and it stuck. Because the value is one number tied to UTC rather than to any local clock, a moment recorded in Tokyo and a moment recorded in London compare directly: the larger integer is the later event, with no timezone math in between. A timestamp like 1714694400 is 8 characters of ASCII, sorts as plain text or as a number, and means the same thing on every operating system, database, and programming language that reads it. That portability is why logs, file modification times, JSON web tokens, database rows, and HTTP caching headers all lean on it. The number grows by exactly 86400 each day, 3600 each hour, and 60 each minute, so 1714694400 and 1714694460 sit precisely 1 minute apart no matter where either was recorded.

The 1 subtlety that trips people up is that Unix time is not a literal count of every physical second since 1970. It deliberately ignores leap seconds, the 27 extra seconds the world's clocks have inserted since 1972 to keep UTC aligned with the Earth's slightly irregular rotation. A Unix day is always exactly 86400 seconds, so on a leap-second day the counter either repeats or skips a value to stay on that fixed 86400 grid. This keeps the arithmetic simple, converting a timestamp to a date is just division and modulo, at the cost of being a few dozen seconds off from true elapsed physical time. For almost every application that trade is invisible and correct; only systems doing sub-second astronomical or metrological work ever need to care.

Seconds or milliseconds: the 10-digit versus 13-digit split

The most common real-world bug with epoch values is mixing up the unit. Classic Unix tooling, most databases, and the value printed by the datecommand in a shell all count whole seconds, which lands today's timestamps at 10 digits. JavaScript is the loud exception: Date.now() and new Date().getTime() both return milliseconds, giving a 13-digit number, and Java, Node, and many APIs follow the same millisecond convention. Feed a 13-digit millisecond value into code expecting seconds and you get a date roughly 50000 years in the future; feed a 10-digit second value into code expecting milliseconds and everything collapses to a few minutes after midnight on 1 January 1970. This tool auto-detects the difference by magnitude, treating any value above 9999999999 as milliseconds, and flags when it has done so, but in your own code the safe habit is to store the unit explicitly or standardize on 1 of the 2 everywhere. A quick sanity check: a seconds timestamp in the 2020s is 10 digits and starts with 17, a milliseconds timestamp is 13 digits. Seconds crossed 10 digits at 1000000000, which fell on 9 September 2001, and will not reach 11 digits until 20 November 2286, so 10 digits is a safe assumption for any near-term date.

The Year 2038 problem is a real 32-bit ceiling

Systems that store Unix time in a signed 32-bit integer have a hard limit. The largest value such an integer can hold is 2147483647, which as a Unix timestamp is 03:14:07 UTC on 19 January 2038. One second later the counter overflows and wraps to the most negative value it can represent, which reads as 20:45:52 UTC on 13 December 1901. Any 32-bit system that has not been updated will, at that instant, believe it has jumped back 136 years, with the same class of consequences the Year 2000 scare warned about: bad sort order, expired-but-not sessions, miscomputed durations, and crashes in code that assumes time moves forward. The fix is already widespread, moving to a signed 64-bit integer, which raises the ceiling to 9223372036854775807 seconds and pushes the overflow roughly 292 billion years out, far past any practical concern. Linux kernels since version 5.6 in 2020 use 64-bit time on 32-bit hardware, and most modern languages default to 64-bit, but embedded devices, old file formats, and legacy database columns are where the 2038 ceiling still lurks. The mirror-image case is the 1901 floor: the most negative signed 32-bit value, minus 2147483648, is 20:45:52 UTC on 13 December 1901, the earliest instant such a field can hold.

What this converter does, and what it leaves to you

Everything here runs in your browser using the JavaScript Dateobject, so no timestamp, log line, or date you paste is sent anywhere or stored. Enter an epoch value in either seconds or milliseconds and it renders 4 views at once: your local time in full, the UTC form, the ISO 8601 string that APIs and databases prefer, and a plain-English relative time such as 3 hours ago that updates live against a 1-second clock. Go the other way by picking a date and time to read back both the seconds and milliseconds forms. The date-to-epoch field interprets the wall-clock time you type in your own browser timezone, which is usually what you want, but it means the same input produces different epoch values for users in different zones, so when a moment must be unambiguous, enter or read it as UTC. The tool does not model timezone rules, daylight-saving transitions, or historical calendar quirks beyond what the browser's own Date implementation provides, and it does not adjust for leap seconds, because Unix time itself does not. Treat the output as an exact conversion of the number you gave it, not as a statement about which zone or unit your source system actually meant.

How to Use

1

Enter a Unix timestamp in seconds (10 digits) or milliseconds (13 digits) to convert it to a date.

2

Or pick a date and time to convert it back to a timestamp.

3

Read the local, UTC, ISO 8601, and live relative-time views side by side.

4

Click the copy icon beside any value to copy it.

Features

Epoch-to-date and date-to-epoch, both directions
Auto-detects seconds vs milliseconds by magnitude and flags which it used
Shows local time, UTC, ISO 8601, and a relative time that updates every second
Live current Unix timestamp with one-click copy and reset
100% client-side — no timestamp or date leaves your browser

Common Questions

About Unix Timestamp Converter

Convert a Unix/epoch timestamp in seconds or milliseconds to a human-readable date, or convert a date back to a timestamp. Auto-detects the unit by magnitude and flags it, and shows local time, UTC, ISO 8601, and a live relative time. Includes a ticking current Unix timestamp, and runs entirely in your browser.

Also known as: unix timestamp, epoch time converter, timestamp to date, unix time, epoch time, posix time, date to unix, milliseconds to date, unix time now, iso 8601 converter, convert timestamp, ms timestamp, year 2038, utc timestamp.

Processing Note

Unix Timestamp Converter runs in your browser, so the input you enter is processed locally on this page and is not uploaded to a ToolMintX account.

Tool Limits

IT tools provide quick diagnostics and transformations. They cannot see every private network, deployment setting, proxy, firewall, or production edge case.

Explore More