Where does the time come from?

Directly from your computer's clock via the browser's Date and performance.now APIs. Accuracy depends on how well your system clock is synced (NTP recommended).

Why microseconds if JavaScript only gives milliseconds?

Microsecond precision is interpolated from performance.now within the current millisecond. It's accurate enough for relative ordering but not a true high-precision clock source.

What's the Unix epoch?

00:00:00 UTC on 1 January 1970, the reference point for Unix time. The current timestamp is the number of seconds (or ms, or µs) elapsed since then, ignoring leap seconds.

Is the time fetched from your servers?

No. The clock reads entirely from your device. Nothing is sent over the network.

live · seconds · milliseconds · microseconds · iso

The current Unix timestamp, live

Refreshes 75 times per second so every representation — seconds, ms, microseconds, ISO 8601 — ticks in real time. Click any value to copy.

Quick Start

How the Unix epoch ticks

The Unix epoch is the count of seconds since 1970-01-01T00:00:00Z. JavaScript, Java, and most modern APIs use milliseconds; Python's time.time() returns seconds with fractions; database TIMESTAMP types vary.

01
Page loads, clock starts
Date.now() runs every 13ms — fast enough to render millisecond changes.
Parsing accepts ISO 8601, RFC 3339, RFC 2822, and Unix epoch seconds/milliseconds. The Date constructor handles the rest with browser-engine consistency.
liveISO 8601RFC 3339epoch
tick · timestamp13ms · ISO
```
Date.now()
```
loaded · ISO 8601zone · ready
02
Six representations
Seconds, ms, µs, ISO UTC, local string, UTC string — same instant in six shapes.
All math runs in UTC internally to avoid DST landmines; presentation converts back to the user’s zone via Intl.DateTimeFormat.
formatsUTC mathIntlDST-safelive
shapes · options6 · live
```
s · ms · µs · iso
```
options applied · UTCDST-safe
03
Pause when needed
Freeze the clock to copy a specific instant. The display stops; the source clock keeps going.
Output respects the chosen timezone offset (Z vs +05:30) and pads digits per ISO conventions so sorts stay chronological.
pauseoffsetzone-awaresortablepadded
freeze · computednow · ready
```
paused
```
computed · instantsortable
04
Click to copy
Every row is a button. Tap once and the value goes straight to your clipboard.
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 grab a timestamp

Logs, filenames, debugging, API calls.

Log entries

Drop a millisecond stamp into a debug print. 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

Filenames

report-1716285600.json sorts chronologically. 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

API testing

Generate a fresh nonce or replay-protection value. 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

Cache busting

Add ?v=<sec> to a static URL to break caches. 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

Cron debugging

Compare expected vs actual fire time at the second. 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

Cross-language demo

Show seconds/ms/µs side by side for teaching. 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

Why are microseconds 'approx'?

JavaScript's Date.now() resolves only to millisecond precision; microseconds are derived as ms × 1000 rather than truly sampled.

Seconds vs milliseconds?

Most modern APIs use milliseconds. Unix syscalls and most C code use seconds. Always check the unit before subtracting timestamps.

How does pause work?

It stops the setInterval. The system clock keeps moving; only this display is frozen until you resume.

Is the local string my browser's clock?

Yes — date.toString() formats with your OS timezone. The Unix value is the same instant for everyone.

Is anything sent to a server?

No — the clock 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!