DevLab
⏱
Time⭐ Popularbeginner

Unix Timestamp Converter

convert between Unix timestamps and human-readable dates

By Bikram NathLast updated

Paste a Unix timestamp like 1716076800 and get the equivalent UTC and local date-time strings instantly; type a date and get the epoch integer back. The live counter showing the current timestamp refreshes every second, which makes it useful for checking whether a JWT or OAuth token's exp field has already passed before making another API call.

Try it now — free, instant, no signup

What is Unix Timestamp Converter?

The tool converts integers representing seconds since the Unix epoch (1970-01-01 00:00:00 UTC) into formatted date strings, and converts date strings back to integers. Type 0 and you get 1970-01-01T00:00:00Z. A live display shows the current epoch second, ticking in real time.

If you're already in a terminal, date -d @1716076800 on Linux or date -r 1716076800 on macOS covers timestamp-to-date without a browser tab. EpochConverter.com is a close online equivalent. This tool earns its keep when you're mid-session in a browser and need both conversion directions without remembering platform-specific flag syntax, or when you want the live current-timestamp counter visible alongside your conversion.

The most common cause of wrong output is conflating seconds with milliseconds. JavaScript's Date.now() returns milliseconds; Unix timestamps conventionally use seconds. A 13-digit number like 1716076800000 is milliseconds; the same value without the trailing three zeros is seconds. If the result lands unexpectedly in January 1970 or mid-2001, the input is almost certainly milliseconds being read as seconds.

When to use Unix Timestamp Converter

✓Verify whether a JWT's exp claim has already elapsed by pasting the integer and reading the converted UTC datetime.
→Construct the exact integer your API expects when its documentation says to pass a Unix timestamp in seconds, not milliseconds.
⚡Audit a log file where timestamps appear as 10-digit integers to determine the real wall-clock time of each event.

Expert Notes

Unix timestamps are always UTC — the most common bug is treating a timestamp as local time when it's actually UTC, which produces errors of exactly your timezone offset. JavaScript's `Date.now()` returns milliseconds, not seconds; a timestamp of `1720000000000` (13 digits) is ms, while `1720000000` (10 digits) is seconds — multiplying by 1000 in the wrong direction is a classic off-by-1000x bug. The Year 2038 problem affects 32-bit signed integers (max 2,147,483,647 = Jan 19, 2038), which is still relevant in embedded systems and some legacy databases.

DevLab's Take

Perfect for decoding timestamps from logs, API responses, and JWT `exp` fields — if you're doing date arithmetic or timezone-aware formatting in code, use a library like `date-fns` or `Temporal` rather than manual conversion.

Frequently Asked Questions

Why does the converted date show a time that's several hours off from what I expected?
The tool renders timestamps in UTC by default. If your log file or API records events in UTC, that output is correct. If you expected local time, the difference equals your UTC offset. A timestamp of 1716076800 displays as 2024-05-19 00:00:00 UTC but as 2024-05-19 05:30:00 in IST (UTC+5:30). Confusion multiplies when the system that generated the timestamp stored local time instead of UTC, which violates the convention that Unix timestamps are always UTC-relative. Check the source system's timezone setting before assuming the converter is wrong.
My timestamp is 13 digits. Why does the converted date land in the wrong year?
JavaScript's Date constructor takes milliseconds, not seconds. A 13-digit value like 1716076800000 is in milliseconds and converts to 2024-05-19. Feed that number to a tool expecting seconds and it reads the value as roughly 54,000 years in the future. The reverse mistake is equally common: a 10-digit seconds value like 1716076800 passed to Date() without multiplying by 1000 gives a date in January 1970, because Date() treats it as 1.7 billion milliseconds. Stripe and most server-side APIs use seconds; browser APIs like Date.now() use milliseconds. Count the digits before converting.
Does this tool handle timestamps beyond 2038, given the Year 2038 problem?
The Year 2038 problem affects systems storing Unix timestamps as 32-bit signed integers, which overflow at 2147483647 (2038-01-19T03:14:07Z). JavaScript stores dates as IEEE 754 64-bit floats, giving a representable range from roughly 271,821 BCE to 275,760 CE. This converter handles timestamps well beyond 2038. The real concern is when the timestamp originates from a C program, a MySQL column typed as INT(11), or any system using 32-bit integers. That integer overflows regardless of which tool converts it; the source value is already corrupted before reaching a converter.
Can I convert a negative Unix timestamp for dates before 1970?
Yes. Negative integers represent moments before 1970-01-01T00:00:00Z. The value -1 is 1969-12-31T23:59:59Z, and -2208988800 corresponds to approximately 1900-01-01T00:00:00Z. JavaScript's Date constructor accepts negative millisecond values without errors, so a negative seconds input is multiplied by 1000 and handled correctly. The main practical use is representing historical dates in database columns or API payloads that store time as integers. Dates earlier than roughly 271,821 BCE fall outside JavaScript's representable Date range and return Invalid Date, but any real-world historical timestamp converts without issues.
How is this different from running 'date -d @1716076800' in the terminal?
The date command on Linux (date -d @1716076800) and macOS (date -r 1716076800) performs the same arithmetic, but output format varies by OS and locale, and neither shows the reverse conversion by default. Getting a date string back into a timestamp requires separate flags. A browser converter handles both directions simultaneously, keeps the current timestamp visible without running date +%s in a second tab, and lets you try multiple values without retyping flags. The terminal wins when you need to batch-process timestamps from a log file using awk or process substitution.

Related Tools

Time
Timezone Converter
convert times between any two time zones instantly
Time
Date Duration Calculator
calculate the duration between two dates or add/subtract time
Time
Cron Expression Generator
build and explain cron schedule expressions with a visual builder
JSON
JSON Formatter
format and prettify JSON with syntax highlighting

Learn more

⏱
Unix Timestamps Explained
Everything you need to know about Unix time — what it is, how it works, and common pitfalls.
⏱
ISO 8601 Explained: The Right Way to Format Dates
Learn the ISO 8601 date and datetime standard, why 2026-06-13T10:30:00Z is unambiguous, and how to use it correctly in APIs and databases.
⏱
Unix Timestamps vs ISO 8601: Which to Use in Your API?
Compare Unix epoch timestamps with ISO 8601 strings for API design, database storage, and JavaScript date handling — with a clear recommendation.