Unix Timestamp Converter

Unix timestamps are everywhere in software systems, but reading "1711670400" and knowing it means March 29, 2024 is not something humans do naturally.

This Unix timestamp converter translates epoch timestamps to readable dates and converts human-readable dates back to timestamps, handling both seconds and milliseconds precision.

Developers encounter Unix timestamps in database records, API responses, log files, JWT tokens, cron job outputs, and system event data. When debugging an issue or analyzing data, you need to quickly convert between machine-readable timestamps and human-readable dates without writing code or doing mental math.

This tool converts in both directions instantly. Enter a Unix timestamp and see the corresponding date, time, and timezone. Enter a date and time to get the Unix timestamp. It handles seconds (10-digit) and milliseconds (13-digit) timestamps, displays results in both UTC and your local timezone, and shows the relative time difference from now.

What Is a Unix Timestamp

A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have elapsed since January 1, 1970, at 00:00:00 UTC. This moment is called the Unix epoch. The timestamp is a single integer that uniquely identifies a point in time, independent of timezones, calendars, or date formats.

At the time of writing, the current Unix timestamp is approximately 1,774,000,000 (a 10-digit number representing seconds). The same moment expressed in milliseconds is approximately 1,774,000,000,000 (a 13-digit number). Systems that need sub-second precision use millisecond timestamps.

The Unix timestamp was adopted in the early days of the Unix operating system because storing time as a single integer is computationally efficient. Comparing two timestamps requires one integer comparison. Calculating the duration between two events requires one subtraction. Sorting events chronologically means sorting integers. This simplicity has made Unix timestamps the dominant time representation in computing.

Seconds vs Milliseconds Timestamps

The most common source of confusion with Unix timestamps is the difference between seconds and milliseconds.

Seconds timestamps are 10 digits (as of 2024). They represent whole seconds since the epoch. Example: 1711670400 represents a date in March 2024. Most Unix/Linux systems, many databases, and many APIs use seconds timestamps.

Milliseconds timestamps are 13 digits. They represent milliseconds since the epoch, providing sub-second precision. Example: 1711670400000 represents the same moment as above. JavaScript’s Date.now() returns milliseconds. Java’s System.currentTimeMillis() returns milliseconds. Many frontend frameworks and event-driven systems use milliseconds.

If you paste a timestamp into this converter and the date seems wildly wrong (showing a date tens of thousands of years in the future), you likely have a milliseconds timestamp being interpreted as seconds, or vice versa. This tool auto-detects the format based on digit count, but you can manually specify seconds or milliseconds if needed.

Timezone Handling

Unix timestamps are inherently UTC. The number 1711670400 means the same absolute moment in time regardless of whether you are in New York, London, or Tokyo. However, the human-readable date and time it corresponds to depends on the timezone you display it in.

1711670400 in UTC is March 29, 2024, 00:00:00 UTC. In Eastern Time (UTC-4), it is March 28, 2024, 20:00:00 EDT. In Japan Standard Time (UTC+9), it is March 29, 2024, 09:00:00 JST.

This tool displays the converted date in both UTC and your local timezone (detected from your browser settings). When converting a date back to a timestamp, you can specify the timezone of the input date to ensure the correct timestamp is generated.

Timezone-related bugs are among the most common issues in software development. Storing times as UTC timestamps and converting to local time only for display is the standard best practice. If a developer stores a local time as a timestamp without accounting for the timezone offset, the stored value will be wrong for anyone in a different timezone.

The Year 2038 Problem

Unix timestamps stored as 32-bit signed integers can represent dates from December 13, 1901, to January 19, 2038. On January 19, 2038, at 03:14:07 UTC, the timestamp value will exceed the maximum 32-bit signed integer (2,147,483,647), causing an integer overflow. Systems still using 32-bit timestamps will roll over to a negative number, interpreting the date as December 13, 1901.

This is often called the Y2K38 problem or the Year 2038 bug. It is analogous to the Y2K problem but affects the internal time representation rather than date formatting.

Most modern systems have already migrated to 64-bit timestamps, which can represent dates far beyond the lifespan of human civilization (approximately 292 billion years into the future). However, legacy systems, embedded devices, and older databases may still use 32-bit timestamps. If you are working with systems that need to handle dates beyond 2038, verify that they use 64-bit time representations.

Common Timestamp Operations

Current timestamp. This tool shows the current Unix timestamp in real time. For reference, the current timestamp updates every second, giving you a live display of the current epoch time.

Date difference. To calculate the time between two events, subtract one timestamp from the other. The result is the number of seconds between them. Divide by 60 for minutes, 3600 for hours, or 86400 for days.

Adding time to a date. To find the timestamp one week from a given moment, add 604800 (7 days x 24 hours x 60 minutes x 60 seconds) to the current timestamp.

Start and end of day. The timestamp for the start of a UTC day is always a multiple of 86400. To find the start of any day, divide the timestamp by 86400, round down, and multiply by 86400.

Timestamps in Different Programming Languages

Different languages and environments have their own conventions for working with timestamps.

JavaScript. Date.now() returns milliseconds since epoch. new Date().getTime() also returns milliseconds. To get seconds, divide by 1000 and use Math.floor(). To convert a timestamp to a date object: new Date(timestampInMilliseconds).

Python. time.time() returns seconds as a float (with fractional microseconds). int(time.time()) gives whole seconds. datetime.fromtimestamp(timestamp) converts to a datetime object. For UTC: datetime.utcfromtimestamp(timestamp).

PHP. time() returns seconds since epoch. date() converts to formatted date string. strtotime() parses date strings to timestamps. mktime() creates timestamps from date components.

SQL. MySQL uses UNIX_TIMESTAMP() to get the current timestamp and FROM_UNIXTIME(timestamp) to convert. PostgreSQL uses EXTRACT(EPOCH FROM timestamp) and to_timestamp(epoch_seconds).

Java. System.currentTimeMillis() returns milliseconds. Instant.now().getEpochSecond() returns seconds. Java 8’s java.time package provides comprehensive timestamp handling.

This browser-based converter is useful when you need to quickly interpret a timestamp from any of these environments without context-switching to a code editor or REPL.

For related time and developer tools, see our Cron Expression Generator for scheduling and our JSON Formatter for formatting API timestamps in JSON responses.

Frequently Asked Questions

What is a Unix timestamp?

A Unix timestamp is the number of seconds elapsed since January 1, 1970, 00:00:00 UTC (the Unix epoch). It uniquely identifies a point in time as a single integer, independent of timezones or date formats.

What is the difference between seconds and milliseconds timestamps?

Seconds timestamps are 10 digits and count whole seconds since the epoch. Milliseconds timestamps are 13 digits and provide sub-second precision. JavaScript uses milliseconds; most Unix systems use seconds.

What timezone do Unix timestamps use?

Unix timestamps are always UTC. The integer represents the number of seconds since the epoch in UTC. Converting to local time requires applying the appropriate timezone offset.

What is the Year 2038 problem?

On January 19, 2038, 32-bit signed Unix timestamps will overflow, rolling the date back to 1901. Most modern systems use 64-bit timestamps to avoid this, but legacy systems may be affected.

How do I get the current Unix timestamp?

In JavaScript: Math.floor(Date.now() / 1000). In Python: int(time.time()). In PHP: time(). In a terminal: date +%s. Or simply use this tool which displays the current timestamp in real time.

Can Unix timestamps represent dates before 1970?

Yes, using negative numbers. A timestamp of -86400 represents December 31, 1969. 32-bit systems can represent dates back to December 13, 1901. 64-bit systems can go much further back.

Why do developers use Unix timestamps instead of date strings?

Unix timestamps are compact integers that are efficient to store, compare, and sort. They avoid timezone ambiguity, locale-dependent formatting, and parsing complexity that come with date strings.

How do I convert a Unix timestamp in Excel?

Use the formula =(A1/86400)+DATE(1970,1,1) where A1 contains the timestamp in seconds. For milliseconds, divide by 86400000 instead. Format the result cell as a date/time.

Data accurate as of: March 2026