Unix Timestamp Converter

Translate Between Machine Time and Human Time

Computers overwhelmingly store time as a single number: the count of seconds since midnight UTC on January 1, 1970 — the “Unix epoch”. It is compact, unambiguous, timezone-free and effortless to compare, which is why databases, logs, APIs and file systems all use it. It is also completely unreadable: quick, what date is 1750000000? This converter translates both directions instantly — paste a timestamp to get the human date, or pick a date and time to get the timestamp — with local time and UTC shown side by side, and a live ticker displaying the current epoch time.

How to Use It

1. Timestamp → date: paste any epoch value. The tool detects whether it is seconds (10 digits for current dates) or milliseconds (13 digits) and shows the result in your local timezone and UTC, plus a relative description like “3 days ago”.
2. Date → timestamp: pick a date and time with the inputs, and read off the epoch value in both seconds and milliseconds, with copy buttons.
3. Now: the live current timestamp updates every second — useful for sanity-checking and for grabbing “now” in epoch form.

Seconds vs. Milliseconds: the Classic Trap

Unix tradition and most backends count seconds; JavaScript and many APIs count milliseconds. Mix them up and dates land a thousand times too far: a milliseconds value read as seconds produces a date tens of thousands of years in the future, while a seconds value read as milliseconds yields January 1970. Both symptoms are unmistakable once you know them, and this tool's automatic detection plus explicit display of both units makes the mismatch visible immediately — the single most common timestamp bug, diagnosed at a glance.

Timezones, Stated Clearly

A Unix timestamp has no timezone — it marks an absolute instant, the same worldwide. Timezones enter only when displaying that instant as a calendar date, which is why this tool shows two renderings: your local time (what your machine's clock would say) and UTC (the neutral global reference logs and servers usually use). When a colleague in another country sees a “different time” for the same timestamp, both of you are right — you are reading one instant through two timezone lenses. For debugging distributed systems, compare in UTC; for explaining to users, convert to their local time.

Where This Converter Earns Its Place

• Log forensics: incident timelines arrive as epoch values; turning them into readable dates is step one of any investigation.
• API work: requests and responses carry epoch fields — created_at, expires_at, iat/exp in tokens — that need human verification.
• Database queries: writing a WHERE clause against a timestamp column means converting your target dates to epoch first.
• Scheduling and expiry: computing “30 days from now” as an epoch value for a token or cache entry.

Conversion happens entirely in your browser using its native date engine — instant, offline-capable, and private, with nothing you paste ever leaving the page.

A closing habit for anyone who touches logs or APIs weekly: memorize your current rough epoch neighborhood. Knowing that present-day timestamps start with 17 and are ten digits long lets you spot anomalies instantly — an eight-digit value is from the distant past, a thirteen-digit one is milliseconds, and a value starting with 20 is probably a misread date, not a timestamp at all. This page's live ticker keeps that reference point one glance away.