Epoch Converter: Unix Timestamp to Date

What is Unix epoch time?

A Unix timestamp is a single number: how many seconds have passed since 1 January 1970 at 00:00:00 UTC. That instant is the epoch, and it is where the counting starts.

So 1774000000 is 1,774,000,000 seconds after that moment, which lands on 17 March 2026.

The appeal is that it is one integer with no formatting, no locale and no time zone. Comparing two moments is subtraction. Sorting is numeric. There is no question of whether 03/04/2026 means March or April.

Why 1970?

It was a practical choice, not a symbolic one. Early Unix at Bell Labs counted in 1/60-second ticks in a 32-bit integer, which overflowed in about two and a half years. Switching to whole seconds with a recent, round starting point gave enough range to be useful, and 1970 was recent when the decision was made in the early 1970s.

Seconds vs milliseconds: count the digits

This is the mistake that brings most people to a converter. The number alone does not say what unit it is in, so the only available clue is how long it is.

Ten digits covers seconds for every date from 2001 to 2286, and thirteen covers milliseconds for the same span. That is why digit count is a reliable rule of thumb in practice, and this page uses it for auto-detection while letting you override it.

The failure mode is unmistakable once you know it. Feed a milliseconds value into a seconds parser and you land 50,000 years in the future:

1774000000000 read as seconds  →  year 58164
1774000000000 read as ms       →  17 March 2026

And the reverse gives you 1970:

1774000000 read as milliseconds  →  21 January 1970

Any date near 1970 or absurdly far in the future is nearly always a unit mismatch rather than corrupt data.

Which unit does what

• Seconds: Unix time(), PostgreSQL EXTRACT(EPOCH ...), JWT iat/exp claims, most REST APIs, date +%s.
• Milliseconds: JavaScript Date.now(), Java System.currentTimeMillis(), Kafka record timestamps, most browser and mobile telemetry.
• Microseconds: Python datetime resolution, MySQL fractional seconds, many tracing systems.
• Nanoseconds: Go time.UnixNano(), Prometheus and Elasticsearch internals, OpenTelemetry spans.

A JWT rejected as expired the moment it was issued is the classic symptom of this: exp must be in seconds, and JavaScript hands you milliseconds.

A timestamp has no time zone

This point is worth stating plainly, because it is the source of the second-biggest category of confusion.

1774000000 is one instant. It is 09:46 in London, 10:46 in Berlin, 04:46 in New York and 18:46 in Tokyo — all the same number. The timestamp does not change; only how you choose to display it does.

So "converting a timestamp to IST" is really "formatting an instant using India's rules". Nothing about the underlying value moves.

The direction that does need care is the other one. When you enter a calendar date and time, that wall-clock reading is ambiguous until you say which zone it belongs to. 2026-03-14 09:00 in London and the same reading in Tokyo are nine hours apart as instants. That is why the date input here asks whether you mean local or UTC, and the resulting timestamp changes accordingly.

How to use the converter

1. Paste a timestamp, or use the current one The unit is detected from digit count. Underscores, commas and spaces are stripped, so a value copied from a log with separators works as-is.
2. Override the unit if the date looks wrong Unusual digit counts — a pre-2001 seconds value, or a truncated millisecond value — are where auto-detection needs help.
3. Read every format at once Local time, UTC, ISO 8601 in both UTC and local-offset form, the RFC 1123 HTTP date, seconds, milliseconds, ISO week and day of year. Each copyable row has its own button.
4. Go the other way Enter a date and time in the right-hand panel, choose whether it is local or UTC, and copy the resulting timestamp in seconds or milliseconds.

Examples of dates worth recognising

Seeing 1 January 1970 in a UI almost never means someone entered that date. It means a null, an empty string, or a zero reached a date formatter.

The Year 2038 problem, briefly

A signed 32-bit integer maxes out at 2,147,483,647. One second later it wraps to negative, and the date jumps to December 1901. Modern systems use 64-bit time, which pushes the limit roughly 292 billion years out, but 32-bit timestamps still survive in embedded firmware, legacy database columns and old file formats.

Handy reference points for arithmetic: one hour is 3,600 seconds, one day is 86,400, one week is 604,800, and a 365-day year is 31,536,000.

Use cases

• Reading a log line. Structured logs from Go, Java and most observability tooling store timestamps numerically. Pasting one gives you the moment in your own zone.
• Debugging a JWT. Check whether iat and exp are plausible and in seconds. The JWT Debugger decodes the whole token.
• Building an API query. Turn "start of yesterday, UTC" into the integer a filter parameter expects.
• Checking a database export. A CSV column of ten-digit numbers is almost certainly seconds; converting a few rows confirms the range is sensible.
• Diagnosing a cache TTL. Comparing an expiry timestamp against the current epoch shows whether an entry should still be alive.
• Correlating events across services. When one service logs milliseconds and another logs seconds, converting both to a readable form is how you line them up.

Scheduling the jobs that produce those timestamps? The Cron Expression Generator validates the schedule and shows the next run times.

Privacy

Conversion uses the browser's built-in Date and Intl APIs. Timestamps are not sent anywhere, and your time zone is read locally to render the local-time column.