KKwikfig.

Unix Timestamp Converter

Convert Unix timestamps to human dates and back — epoch seconds or milliseconds, UTC and your local time side by side, with a live ticking current time. Runs entirely in your browser — your numbers never leave this device.

Current Unix time (seconds, ticking live)
…

Epoch → date

Unit
ISO 8601 (UTC)
2023-11-14T22:13:20.000Z
Weekday (UTC)
Tuesday
UTC
Tue, 14 Nov 2023 22:13:20 GMT
Your local time
11/14/2023, 10:13:20 PM

Date → epoch (fields read as UTC)

Epoch seconds
1709208000
Epoch milliseconds
1709208000000

Unix time counts seconds since 1 January 1970, 00:00:00 UTC, ignoring leap seconds. The date-to-epoch direction reads your fields as UTC so the two directions are exact inverses; the local readout above is the same instant shown on your own clock.

How it works

Unix time = seconds since 1970-01-01 00:00:00 UTC (leap seconds ignored) | Milliseconds = seconds × 1000 | Date → epoch: count the days from the epoch (with leap years) × 86,400, plus the time-of-day in seconds

Unix time is a single number: the seconds elapsed since midnight UTC on 1 January 1970, the epoch. It ignores leap seconds and timezones, which is exactly why systems store it — one integer, unambiguous everywhere on Earth. This converter runs in both directions: paste a timestamp and get the ISO 8601 string, the weekday and both UTC and local readings; or enter a date and time and get the epoch seconds and milliseconds back. The date-to-epoch fields are read as UTC, so the two directions are exact inverses with no timezone guesswork.

The one judgement call is the unit. A 10-digit number is seconds; a 13-digit number is milliseconds — JavaScript's Date and many logging pipelines count in milliseconds, while most Unix tooling and APIs count in seconds. Feed milliseconds into a seconds field and you land in the year 56,000-odd; feed seconds into a milliseconds field and you land in January 1970. The unit toggle exists because that factor-of-a-thousand mix-up is the single most common timestamp bug, and the live ticker at the top of the widget shows the current epoch in seconds so you always have a reference magnitude.

Weekdays and ISO strings here are computed in UTC. A timestamp near midnight can honestly be Tuesday in UTC and Wednesday where you sit — the converter shows both readings rather than picking one, because 'the date' of an instant genuinely depends on where the observer is.

Worked examples

A round modern timestamp

Input
Epoch seconds = 1700000000
Working
1,700,000,000 seconds ÷ 86,400 = 19,675.9 days after the epoch. The whole days land on 14 November 2023 and the remaining 0.9259 of a day is 22:13:20 — a Tuesday in UTC.
Result
2023-11-14T22:13:20.000Z — Tuesday

The epoch itself

Input
Epoch seconds = 0
Working
Zero seconds after the epoch is the epoch by definition: midnight UTC on 1 January 1970, which fell on a Thursday. Negative timestamps walk backwards from here — −1 is the last second of 1969.
Result
1970-01-01T00:00:00.000Z — Thursday

A leap-day date back to epoch

Input
Date = 2024-02-29, Time = 12:00:00 UTC
Working
2024 is a leap year, so 29 February exists. Counting days from the epoch to 2024-02-29 and adding 12 hours (43,200 seconds) gives the timestamp — convert it back above and you land on the same date, because the fields are read as UTC.
Result
1709208000

Frequently asked questions

Is my timestamp in seconds or milliseconds?

Count the digits. Current timestamps in seconds have 10 digits (1.7–1.8 billion in the mid-2020s); in milliseconds they have 13. The converter's ticker shows the current value in seconds — compare magnitudes and pick the matching unit. The 1700000000 example is seconds; as milliseconds it would be 21 January 1970.

Why does the same timestamp show two different dates?

Because a date is a local concept and a timestamp is a global one. 1700000000 is Tuesday 22:13 in UTC, but already Wednesday morning in timezones far enough east and still Tuesday afternoon in the Americas. The tool shows the UTC reading (with weekday) and your local reading side by side instead of silently choosing.

What happens at 19 January 2038?

Systems storing Unix time in a signed 32-bit integer overflow: 2^31 − 1 seconds is 03:14:07 UTC on 19 January 2038, and the next second wraps to a date in 1901. 64-bit storage — which this converter and all modern platforms use — pushes the limit to the year 292 billion, so the risk today is legacy embedded and database fields, not the format itself.

Do Unix timestamps include leap seconds?

No. Unix time pretends every day has exactly 86,400 seconds, so the 27 leap seconds inserted since 1972 are simply not counted. That is a feature for arithmetic — subtracting two timestamps gives true elapsed POSIX seconds — and a known discrepancy against astronomical time that only precision timekeeping cares about.

Why is the date-to-epoch direction read as UTC?

So the two directions invert each other exactly. If the fields were read as your local time, the answer would depend on where your browser sits and the round trip would drift by your timezone offset. Enter the UTC wall-clock you mean — the converter's epoch-to-date direction shows the UTC reading to copy from.

Related tools

More in Developer Tools · Browse all tools