Unix Timestamp Converter

A bidirectional Unix timestamp converter that takes any date-like string — raw epoch seconds, milliseconds, an ISO 8601 string, an RFC 2822 wire date, a spreadsheet date — and prints every canonical representation you might need. The transform runs entirely in your browser with zero network calls, so debugging production timestamps, API payloads, and session cookies never leaks the values to a logging server.

Why a dedicated epoch converter

Most online Unix time tools fall into one of three failure modes. Some are stuck supporting only 10-digit seconds and silently misinterpret 13-digit millisecond timestamps as year-55000 dates. Some wrap the conversion behind a server round-trip and log every input. Some require clicking through three separate forms for "seconds to date", "date to seconds", and "ISO to date" when the underlying operation is a single parse-then-format.

This Unix timestamp converter takes a different stance. One smart input field accepts anything that resembles a timestamp or a date. The output grid shows all 12 representations at once — Unix seconds, Unix milliseconds, ISO 8601 in both local and UTC forms, RFC 2822 wire format, two localised human renderings, verbose UTC, relative-to-now phrasing, day-of-week, day-of-year, and ISO 8601 week number. Every card has its own copy button so you can grab just the one format your log viewer needs.

What the converter accepts

• Unix seconds — any integer of 10 digits or fewer, including negative values for pre-1970 dates and fractional seconds for sub-second precision.
• Unix milliseconds — 13-digit integers, the format emitted by Date.now(), most JSON APIs, modern telemetry pipelines, and Java/Kotlin System.currentTimeMillis().
• Unix microseconds — 16-digit integers, common in high-resolution tracing systems and Postgres timestamp columns.
• Unix nanoseconds — 19-digit integers, the native precision of Go's time.Now().UnixNano() and the OpenTelemetry wire format.
• ISO 8601 / RFC 3339 — with or without timezone offset (Z, +05:30, -08:00), with or without fractional seconds.
• RFC 2822 / RFC 5322 — the wire format HTTP headers and email envelopes use (Fri, 01 Mar 2024 12:34:56 GMT).
• Spreadsheet-style strings — YYYY-MM-DD HH:MM:SS is treated as local time to match what Excel, Google Sheets, and most SQL clients display.
• Bare dates — YYYY-MM-DD is treated as UTC midnight, matching Date.parse semantics.

Units are auto-detected by digit count so you never have to pick a dropdown. A 10-digit integer is seconds; a 13-digit integer is milliseconds; a 16-digit integer is microseconds; a 19-digit integer is nanoseconds. Negative inputs are pre-1970 timestamps, and fractional inputs like 1700000000.5 are read as seconds with a sub-second remainder.

What the converter outputs

The output grid is the core of the tool. Every paste produces twelve cards, each with its own copy button:

• Unix seconds — floored integer, the format most CLIs and log parsers want.
• Unix milliseconds — full-precision integer, the format most JSON APIs want.
• ISO 8601 (local) — full precision with explicit +HH:MM offset, so the string is self-describing without timezone metadata.
• ISO 8601 (UTC) — the canonical Z suffix form, produced by toISOString() and what most databases store.
• RFC 2822 — the comma-separated wire format used by HTTP Date headers, SMTP envelopes, and cookies.
• Local (full) — verbose localised rendering with weekday, month name, and timezone abbreviation.
• Local (short) — compact localised rendering suitable for dense UI.
• UTC (full) — the same verbose rendering but pinned to UTC for comparison.
• Relative to now — "2 hours ago", "in 3 days", "last week" using Intl.RelativeTimeFormat.
• Day of week — "Monday", "Tuesday", etc. in your browser's locale.
• Day of year — 1-based 1–366 integer, useful for cron expressions and annual rollups.
• ISO 8601 week number — 1–53 integer following the standard ISO week rule (week 1 contains the first Thursday of the year).

Why this tool exists client-side only

Timestamps are often adjacent to things you should not paste into a server form. Session cookies, trace ids, auth tokens, and customer identifiers all tend to travel alongside the timestamp you are actually debugging. A server-side epoch converter gets a copy of every paste — its logs become a timeline of your debug sessions. This tool uses native Date, Intl.DateTimeFormat, and Intl.RelativeTimeFormat to compute every representation in the browser. There is no POST to format, no analytics on input content, and no third-party script sitting between your clipboard and the output. The Share button encodes your input into the URL fragment (#…), which browsers never send to servers by design, so shared links preserve the same privacy guarantee.

Y2K38 and other epoch landmarks

The Unix epoch has a handful of dates worth knowing when you are debugging a system that might break at one of them. 1970-01-01T00:00:00Z is the epoch itself — any timestamp of zero is either uninitialized state or a deliberately-zeroed default. 2038-01-19T03:14:07Z is the Y2K38 boundary, where int32 Unix seconds overflow. 2106-02-07T06:28:15Z is the unsigned 32-bit overflow, a common failure mode in embedded firmware that treats time_t as uint32. This converter handles all three without overflow because JavaScript's 64-bit Date backing survives well past the year 275000.

Related tools

• UUID Generator — mint v7 time-ordered UUIDs that embed a Unix millisecond timestamp in the leading bits.