ISO Time Converter

What is ISO-8601?

ISO-8601 is the international standard for representing dates and times as strings. The canonical form is 2026-05-20T18:00:00Z — four-digit year, two-digit month and day, T separator, two-digit hour/minute/second, and a zone designator (Z for UTC, or ±HH:MM for an offset). Fractional seconds are optional (2026-05-20T18:00:00.123Z). The standard sorts lexicographically — comparing two ISO strings as text gives the same result as comparing them as dates — which is why it shows up in filenames, log lines and database columns everywhere.

What is a Unix timestamp?

A Unix timestamp is the number of seconds elapsed since 1970-01-01T00:00:00Z, ignoring leap seconds. It is an absolute, timezone-independent number — 1700000000 refers to exactly the same instant whether you’re in Tokyo, Lagos or Berlin. JavaScript, like many newer environments, prefers milliseconds (the value Date.now() returns), so you’ll see Unix timestamps in two main flavours: 10-digit seconds for shell tools, databases, and most languages, and 13-digit milliseconds for JavaScript, browser APIs, and increasingly modern logging pipelines.

The conversion is purely arithmetic — Math.floor(ms / 1000) to go from milliseconds to seconds, seconds * 1000 to go back — but the two values look enough alike (and are wrong by exactly the same factor) that confusing them is a perennial source of bugs.

How the converter works

The tool keeps three representations of a single instant in sync at all times:

1. ISO-8601 string in UTC (2026-05-20T18:00:00.000Z) and in the browser’s local zone.
2. Unix timestamp in seconds (10 digits) and milliseconds (13 digits).
3. Human-readable rendering — Wednesday, 20 May 2026, 18:00:00 UTC — using Intl.DateTimeFormat so it matches your locale’s date conventions.

Edit any one of those and the others recompute. A live now panel ticks at the top of the page so you can grab the current instant in every format with a single click. Pasted input is auto-classified (ISO string, 10-digit seconds, 13-digit milliseconds, RFC 2822) and parsed accordingly, with a clear error if the input is ambiguous.

Common use cases

• Debugging API responses. A JSON field says 1700000000 — is that seconds or milliseconds? Paste and read the human date.
• Log analysis. Server logs in epoch seconds, browser logs in milliseconds, alerting dashboards in ISO; the converter is the glue between them.
• Scheduling and cron. Converting a target wall-clock time into the Unix timestamp your scheduler needs (or vice versa).
• SQL queries against time columns. Postgres to_timestamp(…), MySQL FROM_UNIXTIME(…), BigQuery TIMESTAMP_SECONDS(…) — quickly validate the integer you’re about to paste into a query.
• Timezone audits. Confirming that a server-side timestamp in +00:00 really is the same wall-clock time a client in +05:30 reported.

How to use this ISO time converter

1. The top of the page shows the current instant in every format, refreshing each second. Click any value to copy.
2. To convert an arbitrary timestamp, paste it into the input field. The converter auto-detects:
   • 10-digit integer → Unix seconds.
   • 13-digit integer → Unix milliseconds.
   • String containing T or Z → ISO-8601.
   • Other recognisable formats (RFC 2822, date-only) → parsed via the browser’s Date constructor.
3. The output panel shows the instant as ISO-8601 in UTC, ISO-8601 in your local zone, Unix seconds, Unix milliseconds, and a human-readable date in your locale.
4. To go the other direction, type into the ISO-8601 or human-readable field directly — the integers update.
5. The local-time line displays the IANA zone name (for example Europe/Berlin) and the current offset (+01:00 or +02:00 depending on DST), so there is no ambiguity about which zone “local” means.

Security considerations

This is a parser, not a credential tool, so the security surface is small. Two things to keep in mind:

• Naïve Date.parse. A string like 2026-05-20T18:00:00 (no zone) is interpreted as local time by JavaScript, which means the same string produces different absolute instants on machines in different timezones. The converter flags missing zone designators explicitly so you don’t get a silently wrong answer.
• Leap seconds. Unix time pretends leap seconds don’t exist — a Unix second is a 1/86400th of a UTC day, except on leap-second days when one second is “smeared” or “stepped” depending on the OS. For ordinary application use this is invisible; for sub-second precision over historical dates, no JavaScript-based converter is authoritative.

Privacy

Every conversion is performed by the browser’s built-in Date and Intl APIs running on your CPU. No timestamps are sent to a server, no analytics are collected on the values you enter, and the page works offline once loaded — the live clock ticks from your local machine, not from a remote time source. You can verify in the Network tab: zero requests after the initial load.

Compatibility notes

The tool requires Date, Intl.DateTimeFormat, and Intl.DateTimeFormat().resolvedOptions() — all present in every browser released since 2017 (Chrome 24+, Firefox 29+, Safari 10+, Edge 12+). ISO-8601 output uses the format produced by Date.prototype.toISOString(), which is identical across browsers and accepted as input by every backend language’s date parser (Python datetime.fromisoformat, Go time.Parse(time.RFC3339, …), Postgres timestamptz, and so on).