How does it detect seconds vs milliseconds?

By magnitude. Values around 10 digits are interpreted as seconds, 13 digits as milliseconds, and so on. You can override the unit explicitly when the heuristic is wrong (for example, far-future dates).

Is the timestamp sent to a server?

No. The conversion happens in your browser.

What about leap seconds?

Unix time deliberately ignores leap seconds, and the converter follows the same convention. Each day is exactly 86400 seconds.

Can I use it for negative timestamps?

Yes. Negative values represent dates before 1970-01-01 UTC and are converted using the same epoch rules.

unix · iso 8601 · utc · relative · live

Convert a Unix timestamp to a date

Paste a Unix timestamp in seconds or milliseconds, or any parseable ISO date. Read it in every common format — runs locally in your browser.

Quick Start

How to read a timestamp

A Unix timestamp counts seconds (or milliseconds) since Jan 1 1970 UTC. The tool also accepts any ISO-style date string.

01
Paste a timestamp
Seconds or milliseconds — the tool detects which by length.
Parsing is strict-but-tolerant — comments and trailing commas are accepted on input where the source format historically permits them; output stays canonical.
inputstricttolerantliveparse
input · sourceunix · live
```
1700000000
```
loaded · parsedtarget · ready
02
Read ISO 8601
The international machine-friendly format used in APIs.
Conversion preserves type information where the target supports it (numbers stay numeric, booleans stay boolean) so the destination parser never has to re-coerce.
isotype-preservinglosslesslivememoised
iso · options8601 · live
```
2023-11-14T22:13:20.000Z
```
options applied · liveround-trip
03
Local vs UTC
Local uses your timezone; UTC is what's stored in databases.
Re-encoding is idempotent: running output back through the same converter produces the same bytes, which keeps round-trips git-friendly.
tzidempotentround-tripdiff-cleandeterministic
tz · convertedcompare · ready
```
local: Tue Nov 14…
```
converted · livediff-clean
04
Copy a representation
One-click copy any row — paste into a SQL query or log filter.
Copy writes via navigator.clipboard.writeText; downloads use the target’s native MIME so editors apply the right syntax highlighting on open.
copyclipboardtarget MIMEblobclient-side
✓ · copiedready · done
```
Copied
```
shipped · ready to shipsuccess

Pro tips

Converting between formats, safely

Pick the strictest source format

Lossy formats hide bugs. Choose JSON or YAML as your source-of-truth, convert downstream as needed.

Round-trip in CI

If your converter is idempotent, your CI can verify A → B → A equals the original. Catches subtle data loss.

Numbers vs strings differ

YAML/TOML have a number type; CSV doesn’t. Quote IDs in CSV to keep leading-zero values intact.

Watch character encoding

Source format may be Latin-1 / Windows-1252; target should be UTF-8. Convert encoding before structure.

Preserve comments where you can

YAML and TOML support comments. Don’t silently drop them — they often encode intent.

Schema-aware beats blind

Use a schema to guide conversion. Field types, required-ness, and defaults survive better with structure.

Use Cases

When to convert a timestamp

Debugging logs, JWT exp, database rows.

Log debugging

Decode timestamps in server logs to local time. Type information survives: numbers stay numeric, booleans stay boolean, strings stay strings. The destination parser doesn't have to re-coerce, which avoids the "'true' becomes "true"" bug class.

round-trip safe

JWT exp / iat

Read JWT expiry claims as readable dates. Run output back through the inverse converter to verify idempotent round-trips in CI. A → B → A should produce byte-identical input — if it doesn't, you've found data loss.

type-preserving

Database rows

Translate created_at integer columns. Comments and metadata survive where the target format supports them (YAML, TOML, HCL). The tool doesn't silently drop intent-encoded annotations, which keeps your config self-documenting.

schema-aware

API responses

Spot-check ISO timestamps from third-party APIs. Pair with a schema (JSON Schema, OpenAPI, Zod, Pydantic) to catch shape drift on either side. Catch breaking changes at conversion time rather than at runtime in production.

lossless

Scheduling

Compute relative time for cron and reminders. Output respects target-format conventions: quoting in CSV, indent in YAML, brackets in JSON. Existing parsers don't need patches, and the result drops into legacy pipelines unchanged.

diff-clean

Timezone bugs

Compare UTC vs local to track down DST issues. Encoding-aware: handles UTF-8 vs UTF-16 vs Latin-1 / Windows-1252 transparently. The character-set surprise that breaks "works on my machine" doesn't apply here.

spec-grade

FAQ

Frequently asked questions

Seconds or milliseconds?

10-digit numbers (through year 2286) are treated as seconds, 13-digit as milliseconds.

What's the relative line?

Human-friendly distance from now — '3 days ago', 'in 2 months', etc.

Timezone of Local?

Your browser's current zone, including any DST offset.

Negative timestamps?

Dates before 1970 work — Unix uses signed integers.

Is anything sent to a server?

No. Parsing runs locally in your browser.

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!