Timestamp Converter
Convert between Unix timestamps and human-readable dates with timezone-aware display.
- Free
- No account
- Runs in your browser
- Nothing uploaded
Enter a timestamp or date and click Convert — all processing happens in your browser.
Runs entirely in your browser — your input is never uploaded, logged, or stored.Privacy policy
What is Timestamp Converter?
A Unix timestamp is the number of seconds (or milliseconds) that have elapsed since January 1, 1970 00:00:00 UTC — known as the Unix epoch. It's the standard way computers store and represent points in time, used in databases, APIs, logs, and cryptographic certificates.
This tool converts between Unix timestamps and human-readable dates. It handles both seconds (10 digits, e.g., 1692800000) and milliseconds (13 digits, e.g., 1692800000000), and auto-detects which format you're using. You can also enter a date and get the corresponding timestamp.
Common uses: • Debugging API responses that return timestamps • Checking certificate or token expiry dates • Converting database timestamps to readable format • Verifying log entries across time zones • Understanding when events occurred in distributed systems
The Unix epoch is fixed at 1970-01-01T00:00:00Z. This is not arbitrary — it corresponds to the introduction of the Unix operating system. Timestamps before 1970 are negative numbers, and timestamps after are positive. The maximum 32-bit Unix timestamp is 2147483647 (January 19, 2038), which is the Year 2038 problem — 64-bit systems don't have this limitation.
Conversion between Unix timestamps and dates:
Timestamp → Date: 1. Multiply seconds by 1000 to get milliseconds (if input is in seconds). 2. Create a JavaScript Date object: new Date(timestampMs). 3. Format using toISOString() or toLocaleString() with the selected timezone.
Date → Timestamp: 1. Parse the input date string. 2. Call .getTime() to get milliseconds since epoch. 3. Divide by 1000 for seconds, or keep as-is for milliseconds.
Auto-detection: • If the input is a 10-digit number (1,000,000,000 to 9,999,999,999) → treated as seconds. • If the input is a 13-digit number (1,000,000,000,000 to 9,999,999,999,999) → milliseconds. • Otherwise, parsed as a date string.
Timezone handling: • Unix timestamps are always UTC — they represent an absolute moment in time. • The display timezone affects how that moment is shown, not the underlying value. • Changing the display timezone does not change the timestamp.
Worked examples
- 1692800000 → Wednesday, August 23, 2023 4:53:20 PM UTC
- 1692800000000 → Wednesday, August 23, 2023 4:53:20 PM UTC (milliseconds)
- 1000000000 → Friday, September 9, 2001 1:46:40 PM UTC
- 0 → Thursday, January 1, 1970 12:00:00 AM UTC (the epoch)
- 2147483647 → Tuesday, January 19, 2038 3:14:07 AM UTC (32-bit max)
- 2023-08-23T16:53:20Z → 1692800000
How to use Timestamp Converter
- Paste a Unix timestamp (seconds or milliseconds) to see the human-readable date.
- Or enter a date to get the corresponding timestamp.
- The tool auto-detects whether your input is seconds, milliseconds, or a date string.
- Switch the timezone to see how the same moment appears in different regions.
- Copy any result using the copy button.
Common errors
- Timestamp shows a date in 1970 — your input is likely in milliseconds but interpreted as seconds (or vice versa). Try the other unit.
- Timestamp shows a date in the future — you may have entered milliseconds (13 digits) instead of seconds (10 digits).
- Output differs from online converters — different tools use different default timezones. This tool defaults to UTC.
- Negative timestamp — dates before January 1, 1970 produce negative Unix timestamps, which is correct behavior.
FAQ
What's the difference between seconds and milliseconds?
Unix timestamps in seconds have 10 digits (e.g., 1692800000). Millisecond timestamps have 13 digits (e.g., 1692800000000). Most APIs return seconds, but JavaScript's Date.getTime() returns milliseconds. This tool auto-detects which format you're using.
Why does my timestamp show the wrong date?
The most common cause is a seconds/milliseconds mismatch. If your date is in 1970, you probably have milliseconds being treated as seconds. If it's far in the future, you have seconds being treated as milliseconds. Count the digits: 10 = seconds, 13 = milliseconds.
What's the Year 2038 problem?
32-bit signed integers can store a maximum value of 2,147,483,647, which corresponds to January 19, 2038 03:14:07 UTC. After this moment, 32-bit timestamps overflow and wrap around to negative values (1901). Modern systems use 64-bit integers, which won't overflow until approximately 292 billion years from now.
Are Unix timestamps always in UTC?
Yes. A Unix timestamp is an absolute count of seconds since the epoch (1970-01-01T00:00:00Z). It doesn't have a timezone — it represents the same instant everywhere. The display timezone affects how that moment is formatted, but the underlying number is always UTC.
Can I convert timestamps from before 1970?
Yes. Dates before the Unix epoch produce negative timestamps. For example, 1969-12-31T23:59:59Z is -1. This tool handles negative values correctly.
Related tools
Prefer AllUtil on Google
One click adds AllUtil to your Google preferences. You'll see our tools highlighted with a Preferred badge in Search and AI answers.