Epoch / Unix Timestamp Converter
Convert a Unix timestamp to a date and back, live. It auto-detects seconds vs milliseconds, shows each result in UTC, your local time and ISO-8601, and adds a plain-English relative time like "3 days ago". A live ticker shows the current epoch in seconds and milliseconds. Everything runs in your browser; nothing is uploaded.
Current Unix time
live · UTCTimestamp → date
Date → timestamp
Common epochs
- The Unix epoch1970-01-01T00:00:00Z — where Unix time starts.
- Y2K2000-01-01T00:00:00Z — the millennium rollover.
- 1,000,000,000 (1 billion)2001-09-09T01:46:40Z — "Unix billennium".
- 12345678902009-02-13T23:31:30Z — a famous round-number moment.
- Signed 32-bit overflow2038-01-19T03:14:07Z — the "Year 2038 problem" limit.
Runs entirely in your browser — no timestamp you enter is ever sent to a server.
What this tool is
- A free, in-browser converter between Unix/epoch timestamps and human dates — paste a timestamp to get the date, or pick a date to get the timestamp.
- Auto-detects whether a number is in seconds or milliseconds from its magnitude, and lets you override the unit when you need to.
- Shows every result three ways — UTC, your local time, and ISO-8601 — plus a plain-English relative time like "3 days ago" or "in 2 hours".
- A live current-epoch ticker displays the running Unix time in both seconds and milliseconds, with one-click copy.
- Everything runs client-side — no timestamp you enter ever leaves your browser, which is handy when correlating log times from a sensitive investigation.
What is Unix / epoch time?
Unix time — also called epoch time — is the number of seconds since 1970-01-01 00:00:00 UTC, the moment known as the Unix epoch. Leap seconds are not counted, so the value is a single, steadily-increasing integer. Because it carries no timezone, no month names and no formatting, it is an unambiguous way to pin down a moment: two machines anywhere on earth agree on what 1700000000 means (2023-11-14T22:13:20Z) without negotiating a format.
Seconds vs. milliseconds
Not every system counts in seconds. Classic Unix, most databases and JWT claims use seconds (a current value is ~10 digits), while JavaScript's Date.now(), Java and many log pipelines use milliseconds (~13 digits). Mixing the two silently turns a 2023 date into 1970 or the far future, so this converter auto-detects the unit by magnitude (anything ≥ 1e12 is read as milliseconds) and lets you override it when a value is ambiguous.
The Year 2038 problem
Systems that store Unix time in a signed 32-bit integer can only reach 2147483647 — which arrives at 03:14:07 UTC on 19 January 2038. One second later the counter overflows to a negative number and the date wraps back to 1901. The fix is 64-bit time; the risk lives on in embedded devices, legacy databases and long-lived certificates, which is why 2038 is worth checking when you audit old infrastructure.
Why logs and security tools use epoch time
- Correlating a timeline. In an incident you often have a firewall, an EDR agent, an identity provider and a cloud audit trail each logging in its own zone and format. Normalising every event to its epoch value lets you line them up on one timeline to the second — the single most useful move in reconstructing an attack.
- Unambiguous records. An epoch integer sorts correctly as a number, needs no timezone metadata and is trivial to subtract to get a duration — which is why machine logs, metrics and databases prefer it over formatted strings.
- Token lifetimes. JWT
iat,expandnbfclaims are epoch seconds. Converting them tells you instantly whether a token is expired or minted in the future. - Offline and private. This converter runs fully in your browser, so a timestamp from a sensitive case never touches a server.
Tip: when a timestamp looks like the wrong decade, you have almost always mixed up seconds and milliseconds — flip the unit toggle before assuming the data is bad.
Frequently asked questions
What is a Unix timestamp?
A Unix timestamp (also called epoch time or Unix time) is the number of seconds that have elapsed since the Unix epoch — 00:00:00 UTC on 1 January 1970 — not counting leap seconds. Because it is a single integer in UTC with no timezone, no month names and no formatting, it is an unambiguous, language-neutral way to represent a moment in time. For example, 1700000000 is 2023-11-14T22:13:20Z. Systems store and exchange timestamps this way precisely so that two machines in different timezones agree on exactly when something happened.
Is the timestamp in seconds or milliseconds?
It depends on the system. Classic Unix, most databases, JWT claims and many APIs count in seconds, so a current timestamp is about 10 digits (e.g. 1700000000). JavaScript (Date.now()), Java and many logging and telemetry pipelines count in milliseconds, so a current timestamp is about 13 digits (e.g. 1700000000000). This converter auto-detects the unit from the magnitude of the number — anything 1e12 or larger is treated as milliseconds — and you can force seconds or milliseconds with the unit toggle if a value is ambiguous.
What is the Year 2038 problem?
Many older systems store Unix time in a signed 32-bit integer, which can only count up to 2,147,483,647 seconds. That value is reached at 03:14:07 UTC on 19 January 2038, after which the counter overflows to a large negative number and the date wraps back to 1901. The fix is to store time in a 64-bit integer, which pushes the limit hundreds of billions of years into the future. It matters for anyone auditing embedded devices, legacy databases or long-lived certificates, because a 2038-sensitive system can mis-handle any future date that crosses the boundary.
Why do logs and security tools use epoch time?
Epoch time is ideal for machine records because it sorts correctly as a plain number, needs no timezone metadata, and is trivial to compare or subtract. In security and forensics that is a real advantage: when you are correlating events across a firewall, an EDR agent, an identity provider and a cloud audit trail, each system may log in its own local timezone or format, but if you normalise every event to its epoch value you can line them up on one timeline to the second (or millisecond) and reconstruct exactly what happened in what order. Converting a suspicious log timestamp to a readable date — and back — is a routine step in incident triage.