How to use this timestamp converter

Two converters share this page. Paste any Unix timestamp into the first box and it is read instantly — the tool counts the digits to decide whether you pasted seconds (10 digits) or milliseconds (13 digits), then shows that moment as a UTC date in ISO format, the same moment in your own local time, and how long ago it was, or how far ahead it is. To go the other way, pick a date and time in the second box; it is read as your local time, and you get the Unix timestamp in both seconds and milliseconds. The live clock at the top always shows the current Unix time, updating every second, and every main result has a copy button. Nothing is sent to a server — all conversions run in your browser.

What is a Unix timestamp?

Quick answer: A Unix timestamp is a count of seconds since 1 January 1970, 00:00:00 UTC — a moment called the epoch. Timestamp 0 is the epoch itself, 1,700,000,000 is 14 November 2023, and negative numbers count backwards into 1969 and earlier.

Computers prefer one long number to a calendar date because it has no time zones, no month lengths and no daylight-saving gaps to argue about: two systems anywhere in the world can compare timestamps and agree exactly on the order of events. That is why timestamps turn up everywhere — in log files, databases, API responses, cookies and login tokens. The awkward part is reading them: 1700000000 means nothing to a human until it is converted, which is the whole job of this page. Unix time also ignores leap seconds, treating every day as exactly 86,400 seconds, which keeps the maths simple even if it drifts slightly from astronomical time over the years.

Seconds or milliseconds? How the auto-detect works

Different systems store the same moment at different precisions. Unix tools and most server logs count seconds; JavaScript's Date.now() and many APIs count milliseconds; a few systems even use microseconds or nanoseconds. This converter accepts the two common units and tells them apart by length: a value with 12 or more digits is treated as milliseconds, anything shorter as seconds. Because today's timestamps are 10 digits in seconds and 13 in milliseconds, the rule is unambiguous for any realistic date — and the detected unit is always shown with your result, so you can check it before copying. One caution: a microsecond value (16 digits) would be read as milliseconds and land far in the future, so divide those by 1,000 first.

UnitDigits todayExampleSame moment (UTC)
Seconds10170000000014 Nov 2023, 22:13:20
Milliseconds13170000000000014 Nov 2023, 22:13:20
Microseconds161700000000000000Not accepted — divide by 1,000

Where you will meet each unit in practice: PHP's time() and Unix shell tools such as date +%s return seconds, while JavaScript's Date.now(), browser event timestamps and many JSON APIs return milliseconds. Database functions differ too — MySQL's UNIX_TIMESTAMP() gives seconds, while several NoSQL stores keep milliseconds. When a converted date lands in 1970 or tens of thousands of years in the future, a unit mix-up is almost always the cause: the value was read as seconds when it was really milliseconds, or the reverse. Check the digit count before anything else.

UTC versus your local time

Every timestamp is a single instant, but the clock reading depends on where you stand. This page always shows both: the UTC version in ISO 8601 format (the Z at the end means UTC), and the local version using the time zone your browser reports — the same zone named above the date picker. Neither is more correct; UTC is the shared reference developers log and compare, while local time is what the moment read on a wall clock. Most “wrong time” bugs are really zone bugs: a timestamp converted with the wrong zone shifts by whole hours, which is why this tool labels every output with its zone instead of leaving you to guess.

Famous timestamps worth knowing

TimestampDate (UTC)Why it matters
01 Jan 1970, 00:00:00The epoch — where Unix time begins
-131 Dec 1969, 23:59:59One second before the epoch
10000000009 Sep 2001, 01:46:40The one-billion-second mark
170000000014 Nov 2023, 22:13:20A typical modern timestamp
214748364719 Jan 2038, 03:14:07The largest 32-bit signed timestamp

The last row is the Year 2038 problem: older systems store timestamps in a signed 32-bit integer, which runs out at 2,147,483,647 seconds. Past that moment those systems wrap around to 1901. Modern 64-bit systems — including the JavaScript running this page — are not affected.

Honest limitations, and your privacy

Three limits are worth knowing. First, the date picker reads times as your browser's local time — there is no UTC mode for it, so to convert a UTC wall-clock time, work from the timestamp box instead. Second, JavaScript dates cover roughly 271,821 BCE to 275,760 CE (about 100 million days either side of the epoch), and this tool rejects anything outside that range rather than showing a wrong date. Third, precision below a millisecond is not kept: fractional seconds are accepted, but microsecond and nanosecond values must be scaled to milliseconds first. Privacy is simpler: every conversion happens on your device, the values you paste are never transmitted or stored, and the page keeps no history of what you converted.