Unix Timestamp Converter

Processed locally · Never leaves your browser

Convert Unix timestamps to human-readable dates and vice versa. See time in multiple timezones simultaneously.

Current Time

Updates every second

1778184319
Thu, 07 May 2026 20:05:19 GMT
Unix (sec)1778184319
Unix (ms)1778184319681
ISO 86012026-05-07T20:05:19.681Z

Timestamp → Date

Enter a Unix timestamp (seconds or milliseconds)

Date / String → Timestamp

Enter any date string or ISO 8601

Common Timestamp Formats

Unix (sec)
1700000000

Seconds since Jan 1 1970 UTC

Unix (ms)
1700000000000

Milliseconds since epoch

ISO 8601
2023-11-14T22:13:20Z

International standard, UTC

RFC 2822
Tue, 14 Nov 2023 22:13:20 +0000

Email/HTTP header dates

Runs entirely in your browser — nothing is uploaded
Runs entirely in your browser. No uploads. Your files stay private.

What Is a Unix Timestamp?

A Unix timestamp is the count of seconds (or milliseconds) that have elapsed since 00:00:00 UTC on 1 January 1970 — the Unix epoch defined by POSIX. It is the most widely used time representation in software because a single integer is unambiguous, sortable, comparable in constant time, and free of timezone metadata. Filesystems, databases, log formats, JWT claims, HTTP cache headers, and almost every API expressing a moment in time use it.
This converter is built entirely on the browser's native Date object. Date.now() returns the current time as milliseconds since the epoch; new Date(ms) constructs a Date from milliseconds; toISOString(), toUTCString(), and toLocaleString() emit the three most common readable formats. The seconds-vs-milliseconds heuristic is simple — values above 10^12 (about year 2001 in seconds) are treated as milliseconds, since any seconds-based timestamp that large would be far in the future.
Time-zone conversion is delegated to Intl.DateTimeFormat under the hood (toLocaleString supports a timeZone option that follows the IANA time-zone database). The dropdown lists eleven common zones; any IANA identifier — Europe/Helsinki, Asia/Singapore, Pacific/Auckland — works if you wire it in. Daylight saving transitions are honored automatically because the IANA database tracks rules per zone and per year.
There is a famous limitation worth understanding: the Year 2038 problem. A 32-bit signed integer can hold timestamps only up to 2,147,483,647 seconds, which is 03:14:07 UTC on 19 January 2038. Beyond that, 32-bit systems wrap around to negative numbers, breaking systems that still use time_t as a 32-bit value (some embedded firmware, older databases, old C code). Modern Linux, macOS, Windows, and JavaScript all use 64-bit integers and are safe through year 292 billion, but the 2038 cutoff still appears in legacy infrastructure.
ISO 8601 is the format you should standardize on for cross-system communication: YYYY-MM-DDTHH:mm:ss.sssZ. The trailing Z signals UTC; replacing it with an offset like +05:30 or -08:00 conveys local time without ambiguity. Avoid month-day-year shorthand (1/2/24 means different things on different sides of the Atlantic) and avoid plain HH:mm strings without a date or zone — they cannot be parsed without ambient assumptions.
The Date constructor's parser is famously lenient about ISO 8601 but inconsistent on free-form input. "Jan 15 2024" parses on most engines; "2024-1-1" might or might not; "15/01/2024" is interpreted as US-format and produces wrong results in many cases. For production parsing where the input format is known, prefer date-fns parse, Day.js custom parse, or Temporal.PlainDateTime.from once it ships. This converter uses the built-in parser because the use case is exploratory.
Everything runs locally. The current-time display is driven by setInterval ticking every second; the conversions are pure functions of input. No server is contacted, no analytics collected. Closing the tab discards the inputs.

Common Use Cases

01

JWT claim debugging

Convert exp, iat, and nbf integer claims into readable timestamps to reason about token expiry.

02

Log file inspection

Translate timestamps embedded in syslog, JSON logs, or access logs into local time for review.

03

Database date columns

Convert between BIGINT timestamps stored for performance and human-readable dates during ad-hoc queries.

04

Cron and schedule planning

Pick a future date in a friendly timezone, then copy the Unix timestamp into your scheduler config.

Frequently Asked Questions

1970-01-01 00:00:00 UTC. Every Unix timestamp counts seconds (or milliseconds, microseconds, nanoseconds in higher-precision variants) since that instant. It predates timezones in the integer itself — the value is always UTC.
Length: 10 digits is seconds (good through 2286), 13 digits is milliseconds. The converter assumes any value above 10^12 is milliseconds. If you have microseconds (16 digits) or nanoseconds (19 digits), divide first.
A 32-bit signed integer overflows at 2147483647 seconds, which is 03:14:07 UTC on 19 January 2038. Systems that still treat time_t as 32 bits will wrap to negative numbers and produce dates in 1901. Most modern systems already use 64-bit time, but embedded devices and legacy databases remain at risk.
Because it does not. The integer represents one moment in absolute UTC; what changes is the local clock display. 1700000000 is 2023-11-14 22:13:20 UTC, which is 17:13:20 in New York and 07:13:20 the next morning in Sydney — same instant, different wall-clock readings.
JavaScript's Date constructor accepts ISO 8601 (the safe choice), RFC 2822 dates like Tue, 14 Nov 2023 22:13:20 +0000, and a wide range of locale-flavored strings. Behavior on ambiguous inputs varies by engine, so for production use a real date library.
Almost always a UTC vs local-time confusion. 2024-01-01 with no time or zone is parsed as midnight UTC; converting to a local timezone west of UTC will show 31 December. Append T00:00:00 and the desired offset to lock the calendar day.
It updates once per second via setInterval, so it can be off by up to one second from the actual clock. Browser clocks are themselves synced via the OS, which on most modern systems uses NTP. For sub-second accuracy use performance.now() instead, which is monotonic.
No, and JavaScript's Date does not either. Unix time is officially defined to skip the leap-second adjustments published by IERS, treating every day as exactly 86400 seconds. For high-precision astronomy or telemetry, use a leap-second-aware library.
Not from this tool — inputs live in component state and are never reflected in the URL. If you need a shareable record, copy the displayed value.
No. The conversions use the built-in Date and Intl.DateTimeFormat APIs and run in your browser. Nothing is logged or transmitted.

Advertisement