Skip to content
$ epochly

The Current Unix Timestamp

The epoch count right now, in seconds and in milliseconds, read from your own device clock and updated ten times a second. Freeze it to copy without chasing a moving number. Nothing here is precomputed — a static page cannot know what time you are reading it.

~/epochly — now
epoch now
··········seconds · 10 digits
epoch now (ms)
··········milliseconds · 13 digits
UTC · ISO 8601
starting clock…
Local time
resolving your time zone…

Where the number comes from

Your browser reports the number of milliseconds since 1970-01-01T00:00:00Z that your operating system believes have elapsed. Dividing by 1000 and flooring gives the seconds form. That is the entire pipeline: there is no server call, no time API, no correction. Whatever your machine thinks the time is, that is what this page shows, which is exactly what you want when the question is "what timestamp will my code produce right now".

It also means the number inherits your machine's clock accuracy. A device synchronised with NTP usually sits within a few milliseconds of true time. A device whose clock has never been set, or a virtual machine resumed from a snapshot, can be far out — and if that machine is writing timestamps, the drift is now in your data permanently. When a log looks impossible, comparing this readout against a colleague's is a fast way to find out whose clock is lying.

Epoch milestones: the numbers worth recognising

Being able to place a timestamp by eye is a genuinely useful skill, and it only takes a handful of reference points. Every value below was computed by script and is re-derived and asserted in this site's test suite, so the dates cannot drift from the numbers.

Each row is new Date(value × 1000).toISOString() — except the final row, which is read as milliseconds rather than seconds, and is included precisely to show what a unit mix-up does to a familiar number.
Value Unit UTC instant Weekday What it is
0 s 1970-01-01T00:00:00.000Z Thursday The epoch itself. Zero is a real timestamp, not a null — a 0 in a database column usually means "nobody set this field".
-1 s 1969-12-31T23:59:59.000Z Wednesday One second before the epoch. Negative timestamps are legal and describe pre-1970 dates.
1000000000 s 2001-09-09T01:46:40.000Z Sunday The first 10-digit timestamp. Every "current" timestamp has had 10 digits since this instant.
1500000000 s 2017-07-14T02:40:00.000Z Friday A round marker often used as a sanity value in fixtures and seed data.
1700000000 s 2023-11-14T22:13:20.000Z Tuesday The default value loaded into the converter on this site.
2000000000 s 2033-05-18T03:33:20.000Z Wednesday The last round billion before the 32-bit ceiling — about five years of headroom left at that point.
2147483647 s 2038-01-19T03:14:07.000Z Tuesday 2³¹ − 1, the largest value a signed 32-bit integer holds. One second later it overflows: the Year 2038 problem.
-2147483648 s 1901-12-13T20:45:52.000Z Friday −2³¹, the other end of the signed 32-bit range. A 32-bit time_t that overflows at 2038 wraps around to this instant.
2147483648 ms 1970-01-25T20:31:23.648Z Sunday 2³¹ read as milliseconds instead of seconds — 24 days after the epoch. This is what a unit mix-up looks like: a number that "should" be 2038 lands in January 1970.

Read down the table and some useful reflexes fall out. The epoch itself was a Thursday. A ten-digit value beginning 17 lands between 2023-11-14T22:13:20.000Z and 2027-01-15T07:59:59.000Z; one beginning 20 lands between 2033-05-18T03:33:20.000Z and 2036-07-18T13:19:59.000Z, so the whole 20… prefix sits in the 2030s. And the value that ends 32-bit time is only 1,706 days past the round 2000000000 mark.

The Year 2038 problem, in three numbers

A signed 32-bit integer holds values from −2,147,483,648 to 2,147,483,647. Used as a second count from 1970, that range covers 1901-12-13T20:45:52Z to 2038-01-19T03:14:07.000Z. One second past the top, the arithmetic wraps to the bottom: an affected program does not crash or warn, it reports a date in 1901 and carries on. Anything that compares two timestamps — a cache expiry, a certificate validity check, a scheduler — then makes decisions with the comparison inverted.

Modern 64-bit systems use a 64-bit time_t and are not affected in any meaningful sense. The exposure that remains lives in three places, none of which is fixed by upgrading a CPU: stored data (a column declared 32-bit, a serialised binary record), protocols and file formats that pin a 32-bit time field on the wire, and long-lived embedded devices that will still be running in 2038 and cannot be patched. Checking those is a schema and specification review, not a hardware one.

There is a mirror-image trap in the same neighbourhood, and it is the last row of the table above. 2147483648 is 2³¹, one past the ceiling — but read as milliseconds rather than seconds it is 1970-01-25T20:31:23.648Z, three and a half weeks after the epoch. A number people associate with 2038 landing in January 1970 is a good reminder that the unit matters at least as much as the width.

Grab a timestamp without opening a browser

For the common case of "I need the current epoch, now", the shortest forms are worth memorising: date +%s in a GNU shell, date +%s%3N for milliseconds, Date.now() in a browser console or Node REPL, and python3 -c "import time;print(int(time.time()))" where Python is available. The ten-language version of that list — including which calls return seconds and which return milliseconds — is the reference table on the main converter page.

Convert a specific value instead

The live readout answers "what time is it". For "what time was that", the converter below is the same tool as the rest of the site, preloaded with the 2038 boundary so you can watch the detection line explain itself.

~/epochly — convert··········
unit

detected: seconds (s)
10 digits — 1 to 11 digits is read as seconds, because 11 digits of seconds already reaches the year 5138 and nothing longer would still be a second count.

UTC · ISO 86012038-01-19T03:14:07.000Z
UTC · RFC 2822Tue, 19 Jan 2038 03:14:07 +0000
UTC · readableTuesday, 19 January 2038, 03:14:07 UTC
Local timeresolving your time zone…
Local · ISOresolving your time zone…
Relativestarting clock…Months and years are approximated as 30 and 365 days, so this is a distance, not a measurement.
Epoch · seconds2147483647
Epoch · milliseconds2147483647000
try

Current timestamp FAQ

01 What is the Unix timestamp right now?
The readout at the top of this page is it, sampled from your own device clock ten times a second. It is not baked into the page — a static file cannot know the time — so if you are reading a cached copy the number is still current, because it is computed in your browser after the page loads. Press freeze to stop it moving while you select and copy it.
02 Why does the number differ slightly from another site?
Because it comes from your computer's clock, and clocks drift. A machine synchronised with NTP is normally within a few milliseconds of true time; one that has never synchronised can be seconds or minutes out. If the difference matters to you, check your system time settings — no web page can correct your clock, it can only report it.
03 How many digits does the current timestamp have?
Ten, in seconds. It has had ten since 1000000000 in September 2001 and will keep having ten until 9999999999 in November 2286. In milliseconds it is 13 digits and in microseconds 16 — the same instant at three resolutions, which is the basis of the auto-detection on the timestamp to date page.
04 What is the Year 2038 problem, exactly?
Software that stores the count in a signed 32-bit integer can hold at most 2³¹ − 1 = 2147483647, which is 2038-01-19T03:14:07.000Z. The next second overflows to −2³¹, which reads as 1901-12-13T20:45:52Z — so an affected system does not crash, it silently reports a date 136 years in the past. Anything using a 64-bit time_t, which is the default on current 64-bit operating systems, is unaffected on any timescale worth worrying about.
05 Is my system already 64-bit safe?
Most likely, but "the OS is 64-bit" is not the same claim. The risk sits in stored data and in protocols: a database column declared INT rather than BIGINT, a binary file format with a 32-bit time field, an embedded device that will still be running in 2038. The audit worth doing is on schemas and wire formats rather than on CPUs.
06 Can I use this page as a clock?
For epoch values, yes — that is what it is for. As a wall clock it is only as good as your device, and it deliberately makes no attempt to correct for drift or to contact a time server, because doing so would mean sending a request from a page that otherwise never makes one.

Related tools