How does it tell milliseconds from seconds?

By digit count. 10 digits is treated as seconds, 13 as milliseconds, 16 as microseconds. You can override the auto-detection when a value is ambiguous.

What's the millisecond epoch range JavaScript can handle?

JavaScript Date supports ±8,640,000,000,000,000 ms from the epoch — roughly ±271,821 years. Java's long is wider but covers the same practical range.

Why is millisecond precision common in APIs?

It's the native resolution of JavaScript's Date object and Java's System.currentTimeMillis, so passing milliseconds avoids precision loss when the client and server use those languages.

Does my data leave the browser?

No. Conversion is a pure local computation.

epoch · milliseconds · js · java · live

Convert epoch milliseconds to a date

JavaScript's Date.now() and Java's System.currentTimeMillis() use milliseconds. Python's time.time() returns seconds. This tool reads millis and shows every common form.

Epoch Milliseconds to Date

Input

valid

Unix sec

1790442324

÷1000

Year

2026

UTC

Status

ready

live

input · epoch ms

parsed

2026-09-26T17:05:24Z

9/26/2026, 5:05:24 PM

output · 6 representations

Quick Start

Why milliseconds?

JavaScript and Java both chose millisecond precision for their default epoch. Unix syscalls and most C code use seconds. Mixing the two is the most common timestamp bug.

01
Paste the number
13 digits = a recent millisecond epoch. 10 digits = seconds — use the seconds converter.
Parsing accepts ISO 8601, RFC 3339, RFC 2822, and Unix epoch seconds/milliseconds. The Date constructor handles the rest with browser-engine consistency.
inputISO 8601RFC 3339epochlive
in · timestamp13 digits · ISO
```
1716285600000
```
loaded · ISO 8601zone · ready
02
Date.now() shape
That's exactly what new Date(n) accepts in JS.
All math runs in UTC internally to avoid DST landmines; presentation converts back to the user’s zone via Intl.DateTimeFormat.
jsUTC mathIntlDST-safelive
JS · optionsDate · live
```
new Date(n)
```
options applied · UTCDST-safe
03
Six representations
ISO UTC, local, UTC string, Unix seconds, microseconds, year.
Output respects the chosen timezone offset (Z vs +05:30) and pads digits per ISO conventions so sorts stay chronological.
formatsoffsetzone-awaresortablepadded
out · computed6 · ready
```
iso · local · y
```
computed · instantsortable
04
Click to copy
Each row is a button — tap to copy that representation.
Copy writes via the Async Clipboard API; nothing pings a time server — the browser’s clock is the only oracle.
copyclipboardno oracledeterministicclient-side
✓ · copiedready · done
```
✓ Copied
```
shipped · ready to shipsuccess

Pro tips

Time math without DST landmines

Always store UTC

Convert to local for display only. UTC storage avoids DST jumps and timezone drift in databases.

Watch leap seconds

POSIX time doesn’t count leap seconds; some systems do. Don’t use timestamps for sub-second precision across boundaries.

Prefer Temporal eventually

The Date API has many quirks. Temporal is shipping in modern engines and handles zones correctly.

Cron is timezone-tricky

Cron expressions run in the daemon’s local zone unless told otherwise. Pin a TZ explicitly for predictable runs.

ISO 8601 sorts naturally

YYYY-MM-DDTHH:mm:ss sorts correctly as a string. Don’t use US-style MM/DD/YYYY for anything machine-readable.

Beware Y2K38

Signed 32-bit Unix timestamps overflow in 2038. Use 64-bit storage end-to-end for long-lived systems.

Use Cases

When to convert epoch ms

Logs, debugging, cross-language work.

Server logs

Read a Java app's millisecond stamp as a human date. Math runs in UTC under the hood to dodge DST jumps — local time is only for display. That means scheduling logic and date diffs survive March / November fall-back without the classic off-by-one-hour bug.

DST-safe

Mobile telemetry

Convert client clock samples while debugging. Browser clock is the only source — no external time server, no privacy leak, no rate limit. Pair with NTP-synced server time for high-accuracy use cases, but for human-scale work the browser clock is plenty.

UTC-correct

Cross-language bugs

Spot when a Python script wrote seconds where JS wanted ms. ISO 8601 output sorts naturally as strings, perfect for filenames (report-2026-01-15.pdf) and log lines that need chronological ordering without parsing. Drop into S3 keys for free time-bucketing.

ISO-sortable

DB inspection

Read a BIGINT created_at column in a SQL row. Pairs cleanly with cron, scheduled tasks, and timestamped log analysis. The tool's output drops directly into APScheduler, Linux cron, or GitHub Actions schedule expressions without re-formatting.

spec-grade

Cookie expiry

Decode a session-cookie expiry value. Output respects the chosen timezone offset (Z vs +05:30) so REST APIs and database TIMESTAMP WITH TIME ZONE columns round-trip cleanly. No ambiguity between "noon UTC" and "noon local".

zone-aware

JWT iat / exp

Spot RFC 7519 claims that mistakenly use ms. Confirms the difference between epoch seconds (10 digits) and milliseconds (13 digits) before you commit code that mis-multiplies by 1000 — a classic bug in cross-language time handling.

epoch-accurate

FAQ

Frequently asked questions

13 digits or 10?

13 = milliseconds, 10 = seconds. Recent ms values look like 1.7e12; seconds look like 1.7e9.

Negative values?

Yes — dates before 1970 are negative epoch values. Try -86400000 for 1969-12-31.

Microseconds?

Some logs use microsecond epoch (16 digits). Divide by 1000 to convert to ms first.

Why two strings?

Local string uses your browser's timezone; UTC string is universal — same instant, different display.

Is anything sent to a server?

No — conversion runs locally in your browser tab.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!