Unix timestamp converter

Paste an epoch timestamp – the converter works out whether it is in seconds, milliseconds, microseconds or nanoseconds and shows the date in UTC, in your time zone and in every common format. It also turns a date into a Unix timestamp.

Source: IEEE Std 1003.1, The Open Group Base Specifications (POSIX, IEEE Std 1003.1-2024) – 4.19 Seconds Since the Epoch. Updated: .

Current Unix timestamp

Unix time (seconds)
–
Milliseconds
–
Leave empty for the current time. Negative values are before 1970.
Empty = your browser’s time zone. Names like America/New_York, Asia/Tokyo or UTC.
My ToolboxYour inputs are saved in this browser only.

Result

Result
Monday, 9 November 2026 at 17:31:00 CET
All formats
FormatValue
Unix time (seconds)1794241860.364
Milliseconds1794241860364
UTCMonday, 9 November 2026 at 16:31:00 UTC
Local time (Europe/Berlin)Monday, 9 November 2026 at 17:31:00 CET
ISO 8601 / RFC 3339 (UTC)2026-11-09T16:31:00.364Z
ISO 8601 with offset2026-11-09T17:31:00.364+01:00
RFC 2822 / 5322 (email)Mon, 09 Nov 2026 17:31:00 +0100
RFC 7231 / 9110 (HTTP)Mon, 09 Nov 2026 16:31:00 GMT
Relative to nownow
Detected unitseconds
No input – showing the current time.

How it is calculated

A Unix timestamp (epoch time) counts the seconds since 1 January 1970, 00:00:00 UTC, the Unix epoch. That is how POSIX defines it (IEEE Std 1003.1, “Seconds Since the Epoch”): every day has exactly 86,400 seconds and leap seconds are not counted. The number is the same everywhere in the world – the time zone only matters when you display it.

How to convert a Unix timestamp

  1. Choose the direction: timestamp to date, or date to timestamp.
  2. Paste the timestamp (let the unit be detected automatically or set it yourself), or enter a date and time and say whether it is in UTC or a time zone.
  3. Read the result – the table lists every format, such as ISO 8601, ready to copy.

Example: The timestamp 1700000000 has 10 digits, so it is in seconds, and equals 14 November 2023 at 22:13:20 UTC – 5:13:20 PM in New York (UTC−5). In milliseconds the same moment is 1700000000000.

Seconds, milliseconds, microseconds, nanoseconds

Many systems store finer units: JavaScript (Date.now()) and Java return milliseconds, Python’s time.time_ns() and Go nanoseconds, PostgreSQL uses microseconds internally. The converter guesses the unit from the number of digits: up to 11 digits seconds, 12–14 milliseconds, 15–17 microseconds, 18–19 nanoseconds. Today a timestamp in seconds has 10 digits, in milliseconds 13. If the guess is wrong, pick the unit yourself.

Output formats

The year 2038 problem

If Unix time is stored as a signed 32-bit integer, it tops out at 231 − 1 = 2,147,483,647 – 19 January 2038, 03:14:07 UTC. One second later the counter wraps to a negative number (13 December 1901). Modern operating systems use 64 bits; the risk lies in old embedded devices, file formats and database columns with 32-bit time. The converter warns you when a value crosses that limit.

Everything is calculated in your browser; nothing is sent anywhere.

More developer tools: read the time inside a UUID v7 with the UUID generator, check data with the JSON formatter and test patterns with the regex tester.

Frequently asked questions

What is a Unix timestamp?

The number of seconds since 1 January 1970, 00:00:00 UTC, ignoring leap seconds (POSIX). For example, 1700000000 is 14 November 2023, 22:13:20 UTC.

How can I tell seconds from milliseconds?

By the length: current timestamps have 10 digits in seconds, 13 in milliseconds, 16 in microseconds and 19 in nanoseconds. The converter detects this automatically.

Does a timestamp depend on the time zone?

No. A timestamp refers to the same instant everywhere. Only the displayed clock time depends on the time zone, which is why the tool shows UTC and local time side by side.

How do I get the current timestamp in code?

JavaScript: Math.floor(Date.now() / 1000); Python: int(time.time()); PHP: time(); Linux shell: date +%s; PostgreSQL: extract(epoch from now()).

What happens in 2038?

On 19 January 2038 at 03:14:07 UTC Unix time reaches 2,147,483,647, the largest value of a signed 32-bit integer. Systems with a 32-bit time_t overflow; 64-bit systems are good for about 292 billion years.

Are leap seconds taken into account?

No – just like POSIX and JavaScript. Unix time pretends every day has 86,400 seconds; system clocks smear or repeat a leap second instead.

Sources and legal basis

As of: · Editorial policy

Related tools