EpochTimeConverter

Epoch time converter

Paste a Unix timestamp, an ISO 8601 date, an HTTP date or a UUID. Every conversion is exact to the nanosecond and runs in your browser. If the unit or zone is a guess, the result says so.

Nowreading device clock…
Unix number in any unit, ISO 8601, RFC 2822, Excel serial, FILETIME, UUID, ULID or Snowflake.
Unit
IANA zone; type to search, e.g. Kolkata, Paris.
Precision and rounding
  • Note: Unit auto-detected as seconds from 10 integer digits.
Same digits in other units
Other formats this number could be (4)
UTCUTC+00:00
2023-11-14 Tue
22:13:20
UTCUTC+00:00
2023-11-14 Tue
22:13:20

Read as Unix seconds (unit auto-detected) high confidence

Precision check: exact vs JavaScript Number and Date
Exact (BigInt)
1 700 000 000 000 000 000 ns
Number(input)
1700000000 (no loss)
new Date(ms)
no loss
Unix epoch
Unix seconds1700000000Exact; fraction shown when present
Unix seconds (integer, floor)1700000000
Unix milliseconds1700000000000
Unix microseconds1700000000000000
Unix nanoseconds1700000000000000000
Unix seconds (hex)0x6553F100
Standard date formats
ISO 8601 (UTC)2023-11-14T22:13:20Z
RFC 3339 (UTC)2023-11-14T22:13:20+00:00
RFC 9557 (offset + zone)2023-11-14T22:13:20+00:00[UTC]
RFC 2822 (UTC)Tue, 14 Nov 2023 22:13:20 +0000
HTTP-date (IMF-fixdate)Tue, 14 Nov 2023 22:13:20 GMTAlways GMT; whole seconds
SQL TIMESTAMP (UTC)2023-11-14 22:13:20Microsecond precision max (PostgreSQL/MySQL)
SQL TIMESTAMP (UTC wall time)2023-11-14 22:13:20No zone stored: ambiguous without context
PostgreSQL timestamptz literal2023-11-14 22:13:20+00:00
ISO week date (UTC)2023-W46-2
Ordinal date (UTC)2023-318
Readable (UTC)Tuesday, 14 November 2023, 22:13:20 UTCCanonical English; not locale-dependent
Platform and system epochs
JavaScript new Date(ms)new Date(1700000000000)
Java InstantInstant.ofEpochSecond(1700000000L, 0L)Nanosecond precision
Python datetime (UTC)datetime(2023, 11, 14, 22, 13, 20, 0, tzinfo=timezone.utc)Microsecond precision
.NET DateTime ticks638355968000000000100-ns ticks since 0001-01-01 (DateTime.Ticks with Kind=Utc).
Windows FILETIME / LDAP133444736000000000100-ns intervals since 1601 UTC. Active Directory lastLogon, pwdLastSet, accountExpires.
Chrome / WebKit time13344473600000000Microseconds since 1601 UTC (Chrome history, cookies).
Apple Cocoa / Core Data721692800NSDate timeIntervalSinceReferenceDate, Core Data, iOS/macOS plists.
Mac HFS+ seconds3782844800Classic Mac OS / HFS+ volume dates (seconds since 1904).
NTP seconds (era 0)3908988800NTP era 0 wraps on 2036-02-07; era numbers are not encoded in the 32-bit field.
Excel serial 1900 (UTC wall time) rounded45244.9259259259Days since 1900-01-00 with the Lotus 1-2-3 leap-year bug (serial 60 = fictitious 1900-02-29). No time zone.
Excel serial 1904 (UTC wall time) rounded43782.9259259259Older Mac Excel workbooks. Days since 1904-01-01. No time zone.
Julian Date rounded2460263.4259259259Days since noon UT, 24 Nov 4714 BC. Computed from UTC, so it ignores the UT1/TT distinction.
Modified Julian Date rounded60262.9259259259JD - 2400000.5. Computed from UTC.
GPS seconds1384035218Seconds since the GPS epoch, counting leap seconds (GPS = TAI - 19 s). Uses the bundled leap-second table.
TAI (TAI-UTC = 37 s)2023-11-14T22:13:57 TAIFrom the bundled leap-second table
ID range bounds
Smallest UUIDv7 at this ms018bcfe5-6800-7000-8000-000000000000Use as a range-query lower bound
Smallest ULID at this ms01HF7YAT000000000000000000
Smallest Twitter / X Snowflake1724551110456246272
Smallest Discord Snowflake1174109840998400000
Smallest MongoDB ObjectId6553f1000000000000000000
Settings and local data

Storage: checking…

What makes a timestamp conversion go wrong

Most epoch bugs come from three silent assumptions. The first is the unit: 1700000000 in seconds is 14 November 2023, but read as milliseconds it lands in January 1970. The second is precision: a 19-digit nanosecond value is larger than JavaScript's Number.MAX_SAFE_INTEGER, so JSON.parse and most web converters quietly change the last digits. The third is the time zone: a date written without an offset, such as 2026-11-01 01:30, can mean two different instants in New York.

This converter treats each of these as an explicit decision. It reads digits as text and does the arithmetic with BigInt. It shows which unit it detected and how confident it is, and lists the other units that would also give a plausible date. When a wall-clock time falls in a daylight-saving gap or overlap, it asks you which instant you meant.

How to use it

Type or paste a value into the input. Auto-detect handles Unix numbers, ISO 8601 and RFC 3339, RFC 2822 and HTTP dates, UUID v1/v6/v7, ULID, MongoDB ObjectId and KSUID. To lock the reading, choose a format and a unit. The UTC and time-zone panels sit side by side. Below them is every representation this site can produce, each with its own copy button: Unix seconds through nanoseconds, SQL literals, .NET ticks, Windows FILETIME, Excel serials, GPS time and more.

Use the tabs to build an epoch from calendar fields, compare time zones, do date arithmetic, convert thousands of rows at once, or copy ready-made code in fourteen languages.

Questions

What is epoch time?
Epoch time (Unix time) counts the seconds elapsed since 1970-01-01T00:00:00 UTC, not counting leap seconds. Many systems store the same count in milliseconds, microseconds or nanoseconds.
Is my data uploaded?
No. Parsing and conversion run in JavaScript in your browser. The site makes no network request with the values you enter. Settings and opt-in history are stored in this browser only.
Why does the result show a confidence level?
A bare number does not say what unit it is in. The converter infers the unit from the digit count and checks whether the resulting date is plausible. It marks low-confidence readings so you can lock the correct unit.
How far back or forward can it convert?
UTC output is exact for years -999,999,999 to +999,999,999 in the proleptic Gregorian calendar. Time-zone output relies on the browser's Intl data, which is limited to the JavaScript Date range (years -271821 to 275760).