Unix Timestamp Converter

Unix Timestamp Converter

Convert any Unix timestamp (seconds or milliseconds) to a human-readable date — or any date back to epoch — instantly. ISO 8601, RFC 2822, UTC, local time, and 10+ timezones in one view.

Current Unix time (live)
— seconds
— milliseconds
—
Unit

ISO 8601 (UTC)

UTC clock

Local time

Local Y-M-D H:M:S

RFC 2822 / HTTP

Relative to now

Day of week

Same instant in major timezones

Why iKit Unix Timestamp Converter

Built for developers debugging logs, APIs, and database timestamps — no signup, no upload, no third party between you and your data.

Live current epoch

The current Unix time updates every second at the top of the page in seconds and milliseconds. One-click copy for either format.

Auto-detects seconds vs milliseconds

Paste any integer — 10 digits is treated as seconds, 13 digits as milliseconds, 16 as microseconds. Override manually with the unit toggle when you need to.

Every common output format

ISO 8601, RFC 2822, UTC clock, your local time, and Y-M-D H:M:S in one view. Plus the day of week and a human-readable relative offset ("2 hours ago").

10+ timezones at a glance

See the same instant in UTC, New York, LA, London, Paris, Tokyo, Shanghai, Taipei, Kolkata, and Sydney — useful for cross-team incidents and global APIs.

Two-way conversion

Switch to Date → Timestamp mode to type "Jan 15 2024 10:30 UTC" or pick from a date-time input, get the Unix timestamp in seconds and milliseconds.

Privacy by design

Everything runs as JavaScript already loaded in your browser tab. Verifiable in DevTools → Network: no fetch, no XHR, no logging. Safe for production timestamps.

How Unix timestamp conversion works

A Unix timestamp is just an integer — but turning it into a date involves a surprising amount of detail.

  1. 1

    Pick the unit

    A Unix timestamp can be in seconds, milliseconds, microseconds, or nanoseconds depending on the source. The first job is to know which one you have. iKit looks at the digit count: ~10 digits = seconds, ~13 = ms, ~16 = µs. You can override the auto-detection with the unit radio buttons.

  2. 2

    Multiply to milliseconds

    JavaScript's Date constructor takes milliseconds, so we multiply seconds × 1000 (or divide microseconds / 1000) to normalise. Internally Date stores the milliseconds since the epoch in a 64-bit float — plenty of range for any realistic timestamp.

  3. 3

    Format for the human

    Once we have a Date object, we ask it to format itself in several ways: toISOString() for ISO 8601 / UTC, toUTCString() for RFC 2822, toString() for the user's local zone, and Intl.DateTimeFormat for any other timezone we want to show.

  4. 4

    Reverse direction

    Going the other way, the browser's Date.parse handles ISO 8601 and many natural formats. The datetime-local input is interpreted in the user's local timezone. getTime() returns milliseconds since epoch; divide by 1000 for seconds.

Common Unix timestamp tasks

Real situations where you'll reach for an epoch converter.

Reading a JWT exp / iat claim

JSON Web Tokens encode iat (issued at) and exp (expires at) as Unix seconds. Paste the number to instantly see if a token is still valid, when it was issued, and how long until it expires.

Debugging a database timestamp column

Postgres extract(epoch from now()), MySQL UNIX_TIMESTAMP(), MongoDB $toDate — they all return Unix epoch. Paste a row's timestamp value to see the actual wall-clock time across timezones.

Comparing log lines from different systems

Application logs in UTC, syslog in local time, an upstream provider's logs in PST. Convert each timestamp to ISO 8601 here, then you can line them up second-for-second when chasing an incident.

Generating cache TTL or cookie expiry

Pick a future date in the picker, copy the Unix timestamp, paste it into a Set-Cookie header, an HTTP Expires field, or your cache TTL config. No mental math, no off-by-one zone errors.

Why local conversion matters

Timestamps from production logs, customer support tickets, audit trails, or test fixtures often look harmless but are tied to user actions and infrastructure events. Pasting them into someone else's server creates a paper trail you don't control. iKit's converter runs as JavaScript already loaded in your browser tab.

  • Zero network requests during conversion — verifiable in DevTools → Network.
  • All math is plain Date arithmetic in JavaScript. No analytics on the timestamps themselves.
  • Safe for production database timestamps, log line offsets, and audit-trail entries.

Frequently Asked Questions

What is a Unix timestamp?

A Unix timestamp (also called "Unix time" or "epoch time") is the number of seconds that have elapsed since 00:00:00 UTC on Thursday, 1 January 1970, ignoring leap seconds. It's the universal time format used in databases, log files, APIs, and cookies. A 10-digit number is seconds (will switch to 11 digits in 2286); a 13-digit number is milliseconds.

What's the difference between seconds and milliseconds?

Most Unix tooling (curl, date, syslog, JWT exp/iat claims) uses seconds. JavaScript's Date.now() returns milliseconds. Java, Kotlin, and many web APIs use milliseconds. If your number is around 10 digits long today, it's seconds. If it's 13 digits, it's milliseconds. iKit auto-detects by digit count, but you can force the unit with the radio buttons.

Are my timestamps uploaded anywhere?

No. The whole tool is JavaScript that runs inside your browser tab. Conversion is plain Date arithmetic — no fetch, no XHR, no beacon. Open DevTools → Network and watch: no requests fire when you type. Safe to paste timestamps from production logs, staging databases, or customer support tickets.

How do I convert a timestamp from a different timezone?

A Unix timestamp is timezone-less by definition — it's the number of seconds since the epoch UTC. Where it appears different is when you display it. The picker on the Date → Timestamp side uses your browser's local timezone. To enter a date in another zone, type it free-form with an explicit offset, e.g. "2024-01-15 10:30:00 +09:00" or "2024-01-15 10:30 UTC".

What about the Year 2038 problem?

32-bit signed Unix timestamps overflow on 19 January 2038. iKit uses JavaScript's Number type (53-bit safe-integer range), so we handle dates well past the year 275000 AD. The Y2038 issue affects systems running 32-bit time_t — most modern OS kernels, databases, and languages have already moved to 64-bit time, but legacy embedded firmware can still hit it.