Skip to main content
ilovecalcs logoilovecalcs.

Dev Tools · Live

Unix Timestamp Converter

Convert Unix timestamps to human-readable dates, or turn any date into an epoch timestamp. Supports seconds and milliseconds, shows UTC and local time, and includes a live epoch clock.

How it worksReal-time

Live epoch clock

1,779,580,210seconds

1,779,580,210,000 ms  ·  2026-05-23T23:50:10.000Z

Input

Detected as seconds

Result

Relative

just now

UTC date

Sat, 23 May 2026 23:50:10 UTC

Local date

Sat, 23 May 2026 23:50:10 UTC+0

ISO 8601

2026-05-23T23:50:10.000Z

Seconds

1779580210

Milliseconds

1779580210000

Reference

Notable timestamps

EventSeconds
Unix epoch (1970-01-01)56 years ago
1 billion seconds25 years ago
1,234,567,890 (famous)17 years ago
2 billion secondsin 7 years
Year 2038 (32-bit max)in 12 years
Year 2100in 74 years

Developer guide

What is a Unix timestamp and why is it everywhere?

A Unix timestamp (also called epoch time or POSIX time) is an integer that represents the number of seconds elapsed since midnight UTC on January 1, 1970. It is the universal language of time in computing: databases store it, APIs return it, logs write it, and every major programming language can produce or consume it without any library imports.

The reason it is so universal is that it is a single integer with no ambiguity about timezones, locale formatting, or daylight saving time. "1700000000" means exactly the same moment everywhere on Earth. Converting it to a human-readable date requires knowing the observer's timezone, but the underlying value is always unambiguous.

Seconds vs. milliseconds

The original Unix timestamp is measured in seconds, but many modern systems use milliseconds for higher precision. JavaScript's Date.now() returns milliseconds, as does Java's System.currentTimeMillis(). The difference is easy to spot: a seconds-based timestamp for the current era is 10 digits long (around 1.7 billion), while a milliseconds-based timestamp is 13 digits long (around 1.7 trillion).

Current seconds: ~1,700,000,000
Current milliseconds: ~1,700,000,000,000

This converter auto-detects the unit based on magnitude and shows which interpretation it used. You can also force seconds or milliseconds manually with the unit selector.

How to get the current timestamp in code

JavaScript: Math.floor(Date.now() / 1000)
Python: import time; int(time.time())
Go: time.Now().Unix()
Rust: SystemTime::now().duration_since(UNIX_EPOCH)
SQL (MySQL): UNIX_TIMESTAMP()
SQL (Postgres): EXTRACT(EPOCH FROM NOW())
Bash: date +%s

How to convert a timestamp to a date

The process is: multiply by 1000 to get milliseconds (if in seconds), then construct a Date object from that millisecond count.

JavaScript:
new Date(1700000000 * 1000).toISOString()
// "2023-11-14T22:13:20.000Z"
Python:
from datetime import datetime, timezone
datetime.fromtimestamp(1700000000, tz=timezone.utc)
# datetime(2023, 11, 14, 22, 13, 20, tzinfo=datetime.timezone.utc)

How to convert a date to a timestamp

Start with a UTC date/time (to avoid ambiguity), then divide the millisecond count by 1000.

JavaScript:
Math.floor(new Date("2023-11-14T22:13:20Z").getTime() / 1000)
// 1700000000
Python:
from datetime import datetime, timezone
dt = datetime(2023, 11, 14, 22, 13, 20, tzinfo=timezone.utc)
int(dt.timestamp())
// 1700000000

UTC vs. local time

A Unix timestamp is always in UTC. When you display it to a user, you need to convert it to their local timezone. Most date libraries handle this automatically, but the distinction matters when storing or comparing times across different timezones. Always store timestamps in UTC; only convert to local time at the display layer.

The converter above shows both the UTC interpretation and your browser's local time. The UTC offset (e.g., UTC+3) is determined by your device's system timezone setting.

The Year 2038 problem

Legacy systems that store Unix timestamps as a signed 32-bit integer will overflow on January 19, 2038 at 03:14:07 UTC, when the value reaches 2,147,483,647 (the maximum positive value for a 32-bit signed integer). After that moment, the value wraps to a large negative number, which most systems interpret as a date in 1901.

Modern 64-bit systems are immune to this problem: they can represent timestamps accurately for billions of years. If you are working on embedded systems, databases with old integer types, or legacy code, this is worth checking.

ISO 8601 format

ISO 8601 is the international standard for date and time representation. The format this converter outputs is:

YYYY-MM-DDTHH:MM:SS.sssZ
Example: 2023-11-14T22:13:20.000Z

The trailing Z means UTC (Zulu time). If you need a local offset instead, the format uses +HH:MM or -HH:MM (e.g., 2023-11-14T22:13:20+03:00). ISO 8601 is unambiguous, machine-readable, and sorts chronologically as a plain string, which makes it ideal for logging, file names, and API responses.

Disclaimer

All conversions are performed in your browser using the JavaScript Date object. The local timezone reflects your device's system setting. Timestamps before 1970 (negative values) are technically valid but may behave differently across platforms. Leap seconds are not counted, matching the POSIX standard.