Unix Timestamp Converter
Convert a Unix timestamp (epoch time) into a human-readable date and time in local and UTC, or turn any date and time into a Unix timestamp in seconds or milliseconds.
Convert Unix Timestamps
Unix Timestamp Formula
Where:
- \(t\) — the Unix timestamp, i.e. the number of whole seconds elapsed since the epoch (Jan 1, 1970 00:00:00 UTC)
- \(ms\) — the same value expressed in milliseconds
- \(t_{\text{offset}}\) — the time zone offset of your location relative to UTC, in seconds
The first line converts a millisecond timestamp to seconds; the second defines what a timestamp means — a simple count of seconds added to the epoch; the third shifts the UTC time into your local time zone.
Unix Timestamp – Calculation Example
Example: convert the timestamp 1735689600 (seconds) into a date.
\[ 1735689600 \div 86400 = 20089 \ \text{whole days} \]
20089 full days after 1970-01-01 lands exactly on 2025-01-01, with 0 seconds left over, so the time is midnight:
Result: 2025-01-01 00:00:00 UTC. In your local time zone the clock reads midnight plus your UTC offset (e.g. 2025-01-01 01:00:00 for UTC+1). In milliseconds the same moment is 1735689600000 ms.
How to Use the Calculator
- Open Conversion Direction and choose either Timestamp → Date & Time or Date & Time → Timestamp; the input fields switch automatically.
- For a timestamp conversion, type the number into Unix Timestamp and pick Seconds or Milliseconds in the Unit box. Negative values work for dates before 1970.
- For the reverse direction, set the Date and, optionally, the Time (leave time empty for midnight). The values are interpreted in your local time zone.
- Read the results: Local Date & Time with your UTC offset, UTC Date & Time, the timestamp in both seconds and milliseconds, and the ISO 8601 & Relative line, which also shows the day of year and weekday.
What Is a Unix Timestamp?
A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have passed since 1 January 1970, 00:00:00 UTC — the “Unix epoch”. Instead of storing a date as separate year, month, day and time-zone fields, computers store a single integer that grows by 1 every second. The timestamp 0 is the epoch itself; 1735689600 is exactly 55 years later, and negative timestamps count backwards to dates before 1970.
This representation is popular because it is compact, easy to compare and completely free of time-zone ambiguity. Sorting events, measuring durations or checking “was A before B?” becomes simple integer arithmetic. You will find Unix timestamps in databases, log files, APIs (e.g. JavaScript’s Date.now(), which returns milliseconds), cron jobs, and webhooks.
When interpreting a result, remember the distinction between UTC and local time. A timestamp always refers to one absolute moment, but the clock reading depends on the viewer’s offset. This calculator shows both: the UTC date and time, which never changes, and your local date and time, which the browser derives from your device’s time zone. The ISO 8601 string (2025-01-01T00:00:00.000Z) is the UTC form, ending in Z for “Zulu time”.
The Relative line gives a quick human sense of scale — “about 6 months ago” or “in 3 days” — which is handy when reading logs from systems whose clock you don’t know, or when a timestamp comes from a header such as an HTTP Date field.
Assumptions, Limitations and Tips
- Seconds vs milliseconds: many systems (JavaScript, Java) use milliseconds, while Unix tools and most APIs use seconds. If your number is 13 digits long it is almost certainly milliseconds; 10 digits usually means seconds. A common bug is treating one for the other, which shifts the date by about 31,700 years.
- Local time zone: in the Date & Time → Timestamp direction, the calculator interprets your input in the time zone configured on your device. If you need a timestamp for a specific UTC moment, convert your local time to UTC first (e.g. subtract your offset).
- Negative timestamps: dates before 1970 are represented with negative numbers; the calculator handles them, but some older systems do not.
- Leap seconds: standard Unix time ignores leap seconds — every day is exactly 86,400 seconds. This matches how virtually all software behaves, so no adjustment is needed for everyday use.
- Range: JavaScript (and therefore this calculator) supports roughly ±273,000 years around 1970, which is far beyond any practical date.
- Quick sanity check: 1,000,000,000 seconds ≈ 2001-09-09; 1,732,000,000 ≈ November 2024. Memorising one or two milestones makes it easy to spot a misplaced digit.
Related Tools
Working with raw data often involves other encodings too. If your timestamp is embedded in a larger payload, try the JSON Formatter to make it readable, the Hex Converter or Binary Converter to inspect numeric representations, and the Base64 Decoder to unpack encoded strings that frequently carry epoch values in URLs and API tokens.
Frequently Asked Questions
How do I convert a Unix timestamp to a date by hand?
Divide the timestamp by 86,400 (the number of seconds in a day) to get the number of whole days since 1 January 1970, then use the remainder to find the time of day. For example, 1735689600 ÷ 86400 = 20089 days with no remainder, which lands exactly on 2025-01-01 00:00:00 UTC. Doing the full day-to-calendar math by hand is tedious because of leap years, so a converter is far more practical.
How can I tell whether a timestamp is in seconds or milliseconds?
Count the digits. A 10-digit number (like 1735689600) is almost always seconds and corresponds roughly to the years 2001–2033. A 13-digit number (like 1735689600000) is milliseconds — the same moment, multiplied by 1000. Mixing them up is the single most common mistake: it shifts the result by about 31,700 years, which is an easy error to spot once you know the rule.
What is the current Unix timestamp right now?
The timestamp grows by 1 every second, so there is no fixed answer — it changes constantly. As handy reference points: 1,700,000,000 was 2023-11-14, 1,750,000,000 is 2025-06-28, and 2,000,000,000 will be 2033-05-18. To get the live value, convert the current date with this calculator or run Date.now() ÷ 1000 in your browser console.
Can a Unix timestamp be negative?
Yes. Negative timestamps count backwards from the epoch, so −86400 is 1969-12-31 00:00:00 UTC and −2,208,988,800 is 1 January 1900. This calculator accepts negative values, but be careful in code: some older systems and databases store timestamps as unsigned integers and cannot represent dates before 1970 at all.
Why does my timestamp show a different time than on the server or in a log file?
A timestamp always marks one absolute moment, but the clock reading depends on the viewer's time-zone offset. The same value 1735689600 reads 00:00 in UTC, 01:00 in UTC+1 and 19:00 the previous day in UTC−5. When comparing values across systems, always convert to UTC first; this is why the calculator shows both the UTC and your local date and time side by side.
What is the difference between Unix time, epoch time and POSIX time?
Nothing — all three names refer to the same thing: the count of seconds since 1 January 1970 00:00:00 UTC. Unix time also deliberately ignores leap seconds, treating every day as exactly 86,400 seconds. This means a timestamp is not perfectly synced to atomic time, but it matches how operating systems, databases and programming languages actually behave, so no correction is needed in practice.
What is the Year 2038 problem?
Older 32-bit systems store timestamps as a signed 32-bit integer, which overflows on 2038-01-19 at 03:14:08 UTC. After that moment such systems may interpret dates as far back in 1901. Modern 64-bit platforms (including JavaScript, which this calculator uses) have a range of roughly ±273,000 years and are unaffected, but the issue still matters for legacy embedded devices and older database schemas.