What this epoch converter does
A Unix timestamp — also called epoch time — is how most computers, databases, and APIs store a moment in time: a single number counting seconds since 1 January 1970. It's compact and unambiguous, but not something a person can read at a glance. This tool converts it both ways: paste a timestamp and get a real date, or pick a date and get its timestamp, in either seconds or milliseconds.
It's built for the moments a raw number shows up somewhere it shouldn't have to be read directly — a log line, an API response, a database column, a JWT's exp claim — and you need to know what it actually means, fast.
How to use it
Either field can drive the conversion — there's no "from" or "to" side.
- Paste a timestamp, or pick a date.Type a Unix timestamp into the first field, or set a date and time in the second — whichever you have on hand.
- Check the unit.A 10-digit number is read as seconds; a 13-digit number is read as milliseconds. The dropdown switches automatically, or set it yourself.
- Read the result.The local date and time, the UTC time in ISO 8601, and both the seconds and millisecond timestamps update the instant you change either field.
- Copy, print, or download it.Reuse the result as text, on paper, or as a CSV row for a bug report or log entry.
How the conversion works
Unix time counts whole seconds that have elapsed since 00:00:00 UTC on 1 January 1970 — the "Unix epoch" — and ignores leap seconds entirely, so every day is treated as exactly 86,400 seconds long. Converting a timestamp to a date means walking forward that many seconds from the epoch and reading off the calendar date and time of day it lands on; converting a date to a timestamp runs the same arithmetic in reverse.
1735689600 seconds1,735,689,600 ÷ 86,400 = 20,089 days since 1 Jan 1970
20,089 days after 1 Jan 1970 = 1 Jan 2025, 00:00:00 UTC
In milliseconds: 1,735,689,600 × 1,000 = 1735689600000
Seconds vs. milliseconds
The core Unix standard counts in whole seconds, which is why database and API timestamps are usually 10 digits (until the year 2286). JavaScript's own clock, and most logging and analytics systems, work in milliseconds for sub-second precision — that's the 13-digit form. Multiply by 1,000 to go from seconds to milliseconds, or divide by 1,000 to go back. For a duration in milliseconds rather than a point in time, the milliseconds to time tool breaks it into hours, minutes, and seconds instead.
Dates before 1970, and the "Y2K38" problem
Unix time can be negative — a timestamp of -86400 is exactly one day before the epoch, 31 December 1969. Older 32-bit systems store timestamps as a signed integer that overflows in January 2038, but this tool uses JavaScript's native date handling, which is unaffected and works correctly for dates far outside that range.
Quick examples
A few timestamps worth recognizing on sight.
| Timestamp | Unit | UTC date & time |
|---|---|---|
| 0 | seconds | 1970-01-01 00:00:00 |
| -86400 | seconds | 1969-12-31 00:00:00 |
| 1000000000 | seconds | 2001-09-09 01:46:40 |
| 1700000000 | seconds | 2023-11-14 22:13:20 |
| 1735689600000 | milliseconds | 2025-01-01 00:00:00 |
Need the reverse direction only, or the ISO 8601 string on its own? The Unix timestamp converter and the ISO 8601 converter are narrower single-purpose versions of the same math.
Who uses it, and for what
- Developers reading a timestamp out of an API response, a JWT, or a database row and needing to know what date it actually represents.
- DevOps & SREs tracing an incident through log files stamped in epoch time, or checking when a scheduled job — set up with the cron expression generator — is due to fire next.
- QA & testers verifying that a "created at" or "expires at" field was written correctly during a test run.
- Data analysts converting an exported CSV or JSON column of raw timestamps into dates a spreadsheet or report can display.
If the question is really about time zones rather than the epoch itself — turning a UTC time into your local time, or vice versa — the UTC converter and GMT converter handle that directly.
Frequently asked questions
What is a Unix timestamp (epoch time)?
It's the number of seconds that have elapsed since 00:00:00 UTC on 1 January 1970 — the "Unix epoch" — not counting leap seconds. It stores a single moment in time as one number, independent of time zone or calendar.
How do I convert a Unix timestamp to a date?
Divide the timestamp by 86,400 seconds per day to get the number of days since 1 January 1970, then work out which calendar date that lands on, accounting for leap years. This tool does that instantly and shows the result in your local time zone as well as UTC.
Does it handle milliseconds as well as seconds?
Yes — a 10-digit number is read as seconds and a 13-digit number as milliseconds, detected automatically as you type. You can also set the unit manually with the dropdown.
Can I convert a date before 1970 or after 2038?
Yes, both. Unix time can be negative for dates before 1970, and this tool isn't limited by the old 32-bit "2038 problem" — it works correctly for dates centuries in either direction, bounded only by what a JavaScript date can represent.
What time zone are the results shown in?
The main result and the date field use your device's local time zone and clock. The ISO 8601 field always shows Coordinated Universal Time, regardless of where you are.
Why do some systems use 10-digit timestamps and others 13?
It depends on the precision needed. Databases, APIs, and most Unix tools count whole seconds — a 10-digit number until the year 2286. JavaScript and many logging systems use milliseconds for sub-second precision, which is 13 digits today.
Is my data private?
Yes. Everything runs entirely in your browser — the timestamps and dates you enter are never sent to a server or stored anywhere.
Accuracy & sources
Results come from standard Unix time arithmetic: the entered value is converted to milliseconds, built into a native JavaScript date, and read back in both your local time zone and UTC — exactly as shown in how the conversion works. There is no external time-conversion service or lookup table involved, and every worked example on this page has been independently verified by hand.
Unix time — seconds elapsed since 1 January 1970 UTC — is formally defined by POSIX / IEEE Std 1003.1 under "Seconds Since the Epoch," and UTC values are displayed using the ISO 8601 date-time format. Written and reviewed by Fletcher Langley, and re-checked whenever the tool changes — last reviewed August 2026.
About the author
Operations and workforce-systems specialist with 14+ years inside shift-based industries and payroll platforms, and a BS in Industrial Engineering. Fletcher writes and reviews the calculators, converters, and guides here — from overnight-shift math to decimal payroll hours — drawing on years spent translating between 12-hour, 24-hour, and military time for real timesheets.
Written & reviewed by Fletcher Langley · Last updated: August 2026