§

Conversion direction

§

Enter a Unix timestamp

§

Output

UTC, your local zone, Tokyo, New York, and London by default
Show in timezones

    Unix timestamps drive nearly every US developer workflow: AWS CloudWatch metrics are bucketed by epoch seconds, GitHub Actions log lines are stamped with RFC 3339 strings, the `iat` and `exp` claims inside every JWT use epoch seconds, and the Stripe API records every charge with a `created` field expressed as Unix time. UK engineers debugging cron expressions against `crontab` on Ubuntu LTS hit the same epoch boundary. This converter translates between epoch seconds, epoch milliseconds, ISO 8601 with offset, and timezone-aware locale strings entirely in the browser — useful when triaging a production incident from a laptop that has no clean Python REPL or shell handy.

    // Related Tools

    ./base64-encoder
    Base64 Encoder
    Encode text and files to Base64 format.
    →
    ./url-encoder
    URL Encoder
    Percent-encode strings for safe transport in URLs.
    →
    ./json-formatter
    JSON Formatter
    Format, validate, and minify JSON in your browser.
    →
    ./
    All Tools
    Browse the full set of Ultim8Soft online tools.
    →

    What is a Unix timestamp?

    A Unix timestamp is the number of seconds (or milliseconds) elapsed since the Unix epoch — 1970-01-01T00:00:00Z. It is the canonical way to represent a moment in time inside log files, API responses, database columns, and JWT claims. This converter renders a timestamp simultaneously across UTC, your local timezone, and any IANA zone you add, and converts in both directions — all in your browser, with zero network requests.

    How does Unix timestamp conversion work?

    The tool runs a small, deterministic pipeline that mirrors the platform's native Date and Intl.DateTimeFormat behaviour:

    1. Magnitude detection. Any numeric input greater than 1012 is treated as milliseconds; anything smaller is treated as seconds. 1700000000 reads as seconds, 1700000000000 reads as milliseconds, and both resolve to the same instant.
    2. Instant construction. The detected value is multiplied to milliseconds if needed, then passed to new Date(ms). The result is a single platform-native instant that does not carry a timezone of its own — it is always a moment on the global timeline.
    3. Multi-timezone rendering. For every active zone in the picker, the tool calls Intl.DateTimeFormat with that zone to produce four parallel views — ISO 8601 with the correct offset, an RFC 2822-style string, a locale-aware long form, and a relative-time phrase like "3 minutes ago".
    4. Date → Timestamp inversion. When you switch direction, the tool reads the datetime-local wall-clock value plus the selected zone, computes that zone's offset at that wall time, and converts back to a UTC instant. Output is rendered as both unix seconds and unix milliseconds with separate copy buttons.
    5. Live ticker. Toggling "Live" on starts a setInterval(tick, 1000) loop that re-renders every cell each second; toggling it off clears the interval and freezes the display. The pulsing dot mirrors the standard live-mode contract used across every Ultim8Soft tool.

    Why use this Unix timestamp converter?

    • Privacy by default. The page makes zero network calls after the initial document load. Your timestamp never leaves the tab — open DevTools, click Convert, and the Network panel stays silent.
    • Seconds and milliseconds in one box. No more guessing which unit your log line uses; the magnitude detector picks the right unit and tells you which one it chose.
    • Multi-timezone at a glance. Compare a payment timestamp across UTC, your engineer's desk in Tokyo, the customer's screen in New York, and the audit ledger in London — all in one render, no calendar maths.
    • RFC-correct output. ISO 8601 uses the exact zone offset, RFC 2822 follows the conventional shape, and the locale view uses your browser's preferred language. Same numbers, four formats, no rounding surprises.

    What are common applications of Unix timestamps?

    Anywhere a system writes time as a number, a Unix timestamp converter is the first tool you reach for:

    • Debugging log lines. Application logs from journald, CloudWatch, Datadog, or Sentry usually carry an epoch column. Paste it here to see the exact wall-clock time across the on-call engineer's zone and the customer's zone in one render.
    • Decoding JWT claims. The iat and exp claims inside a JSON Web Token are unix-second timestamps. Drop them in to see when the token was issued and when it expires — in seconds, milliseconds, ISO 8601, and relative time, side by side.
    • Comparing API response timestamps. REST and webhook payloads emit timestamps in inconsistent units — Stripe uses seconds, Shopify uses milliseconds, GitHub uses ISO strings. Convert the raw integer to verify alignment with the order line, the audit log, and the customer-visible receipt.

    What does a Unix timestamp example look like?

    Take the timestamp 1700000000. The magnitude detector reads it as seconds (it sits well below 1012), so the tool constructs new Date(1700000000 * 1000) — the instant 2023-11-14T22:13:20.000Z. The UTC card shows the ISO string, the RFC 2822 form (Tue, 14 Nov 2023 22:13:20 GMT), the long locale form, and a relative phrase counted from your current clock. The Tokyo card renders the same instant as 2023-11-15T07:13:20.000+09:00, the New York card as 2023-11-14T17:13:20.000-05:00, and the London card as 2023-11-14T22:13:20.000+00:00. Feed the same value as 1700000000000 in milliseconds and you get an identical render — the magnitude detector quietly handles the unit swap.

    This Unix Timestamp Converter does one job: turn a number into a moment, or a moment into a number, across every timezone you care about, without sending the value anywhere. Paste, click, copy, move on.