Epoch Converter
Unix timestamps to dates — and dates back — in seconds, ms, µs and ns.
That 10-digit number in your log file is a moment in time. Paste it here and see the exact date in UTC and your timezone, how long ago it was, and whether it is seconds or milliseconds — auto-detected. The live clock at the top always shows the current epoch.
Right now · live
1795038306
Current Unix timestamp in seconds — Wed, 18 Nov 2026 21:45:06 GMT · 2026-11-18T21:45:06.266Z · updates every second.
Timestamp → date
Convert an epoch timestamp to a human date
Date → timestamp
Convert a date and time to epoch
Everything runs in your browser — timestamps you paste are never sent anywhere.
Done-for-you
Need a tool like this on your own website?
Every calculator on this site was built by WebStore Pro — the same work I do for clients: fast, accurate, mobile-friendly tools and full stack websites from $80. If your site needs a custom calculator, converter or internal tool, I can build it for you.
Prefer email? neilsonsmarry@gmail.com · See my services — or explore the UUID Generator, Base64 Encoder/Decoder and Time Duration Calculator — plus 100+ more free tools on the tools hub.
The method
How epoch conversion works
One number, one instant. Unix time counts seconds from 1970-01-01 00:00:00 UTC. Converting to a date means adding that many seconds to the epoch start; converting back means counting the seconds between your date and the epoch start. Milliseconds, microseconds and nanoseconds are the same idea at finer resolutions — just multiply or divide by 1,000 per step.
Worked example
The timestamp 1762300800 has 10 digits → seconds. Adding it to the epoch gives Wednesday, 5 November 2025, 00:00:00 UTC(2025-11-05T00:00:00.000Z in ISO 8601). Written in milliseconds the same instant is 1762300800000, and in microseconds 1762300800000000.
- Always check the digit count before trusting a converted date (10/13/16/19).
- Store timestamps in UTC; convert to local time only when displaying them.
- JavaScript's Date uses milliseconds; Python's time.time() returns seconds — the classic mix-up.
- For database created_at columns, seconds are plenty; use ms only for ordering fast events.
- Relative time ('3 days ago') is computed against your clock, so it stays live on this page.
Cheat sheet
Epoch time in code — and the key durations
| Language | Current epoch (seconds) | Timestamp → date |
|---|---|---|
| JavaScript | Math.floor(Date.now() / 1000) | new Date(1762300800 * 1000) |
| Python | int(time.time()) | datetime.fromtimestamp(1762300800, timezone.utc) |
| SQL (PostgreSQL) | EXTRACT(EPOCH FROM now()) | to_timestamp(1762300800) |
| SQL (MySQL) | UNIX_TIMESTAMP() | FROM_UNIXTIME(1762300800) |
| PHP | time() | date('Y-m-d H:i:s', 1762300800) |
| Shell | date +%s | date -d @1762300800 (Linux) |
| Duration | Seconds | Milliseconds |
|---|---|---|
| 1 minute | 60 | 60,000 |
| 1 hour | 3,600 | 3,600,000 |
| 1 day | 86,400 | 86,400,000 |
| 1 week | 604,800 | 604,800,000 |
| 1 year (365 days) | 31,536,000 | 31,536,000,000 |
One more number worth knowing: 2,147,483,647 — the largest signed 32-bit epoch value — is 19 January 2038 at 03:14:07 UTC, the moment the Year 2038 problem bites. And 1,000,000,000 was 9 September 2001, a date old Unix hands still celebrate as the “billennium”.
FAQ
Epoch converter questions, answered
What is epoch time (Unix time)?+
Epoch time is the number of seconds that have elapsed since 00:00:00 UTC on 1 January 1970, not counting leap seconds. Computers store dates this way because a single number is easy to save, sort and compare. At the time of writing the epoch is around 1.76 billion — a 10-digit number in seconds, 13 digits in milliseconds.
How do I know if a timestamp is seconds, milliseconds or microseconds?+
Count the digits: 10 digits = seconds, 13 = milliseconds, 16 = microseconds, 19 = nanoseconds. This converter auto-detects the unit from the length of the number you paste (or you can force a unit in the dropdown) — mixing them up is the #1 cause of dates that land in the year 55,000 or 1970.
Why does my timestamp show 1 January 1970?+
A 1970 date almost always means a unit mismatch — most commonly a seconds value fed into a field expecting milliseconds (or a 0/null value). Check the digit count: if the value has 10 digits but the system expects 13, multiply by 1,000. This converter shows the detected unit next to every result so you can spot it immediately.
What is the current epoch time right now?+
The live clock at the top of this page shows it, ticking every second, in both seconds and milliseconds, along with the matching UTC and ISO 8601 date. Programmers grab it constantly for cache-busting, log checks and testing time-based code.
Is epoch time the same in every timezone?+
Yes — that is its main advantage. An epoch timestamp names one exact instant worldwide. It only becomes timezone-dependent when you display it as a local date and time, which is why this converter shows UTC and your local time side by side.
What happens in 2038 (the Year 2038 problem)?+
Systems that store epoch seconds in a signed 32-bit integer overflow at 03:14:07 UTC on 19 January 2038 and wrap to 1901. Modern systems use 64-bit integers, which push the limit to the year 292 billion — but plenty of embedded devices and old file formats still use 32 bits.
Why doesn't Unix time count leap seconds?+
By definition. UTC has inserted 27 leap seconds since 1972 to stay aligned with Earth's rotation, but Unix time simply counts 86,400 seconds per day, every day — so Unix timestamps and UTC clock readings drift apart by those inserted seconds, and two different UTC times can share one Unix timestamp during a leap second. It is a deliberate trade: arithmetic stays trivial, and only astronomy-grade work needs to care.
Can an epoch timestamp be negative?+
Yes — negative values count backwards from the epoch, for dates before 1970. −86,400 is 31 December 1969, 00:00:00 UTC, and historical dates go further back from there. This converter handles them, but watch your language's limits: some platforms (notably older Windows APIs and JavaScript in very old engines) struggle with pre-1970 dates, and JavaScript's Date range is roughly ±273,790 years around 1970.
