Timestamp Converter · Encoding
Turn a Unix epoch into time you can read — and back.
Paste a Unix timestamp like 1700000000 or a date string to convert epoch time to a human-readable date — UTC, ISO 8601, local and relative time at once, all in your browser, across seconds, milliseconds and microseconds.
Timestamp Converter playground
A Unix epoch in seconds 1516239022, milliseconds 1516239022000, or a date string 2018-01-18T01:30:22Z.
Type a Unix timestamp or date string, pick an example, or hit Now to see it in seconds, milliseconds, ISO 8601, UTC and local time here.
Verify an AI's answer
Paste what ChatGPT or Claude told you — this recomputes it exactly, locally. Why AI needs checking →
Enter a timestamp above, then paste in what an AI told you to check it.
| Field | Claimed | Actual | Verdict |
|---|
The Gap
A bare integer in a log is nobody’s idea of a time.
Epoch timestamps are everywhere — log lines, API payloads, database rows, JWT exp claims — and every one of them is just a number until you decode it. Worse, the unit is rarely labelled: is 1700000000 seconds or has someone already multiplied by a thousand? Guess wrong and you are reading a date in 1970 or the year 56000.
This converter takes the integer or date string and gives you the concrete facts: the Unix timestamp to UTC mapping, a strict ISO 8601 string, your own local time, and how long ago it was — with the seconds vs milliseconds unit auto-detected so you never have to guess. Entirely in the browser, with nothing to install.
It’s also a safer path than asking an AI: language models tokenize long numbers and quietly lose place value, so epoch conversions come back off by an hour, a day, or a factor of a thousand — and still look right. This converter does the arithmetic exactly, every time.
Pulling timestamps out of a token? The JWT Decoder reads iat and exp for you.
The Pipeline
How it works.
Four deterministic steps run on every keystroke — all inside your browser tab, with no clock sent to a server.
-
Detect the input.
The value is read as an epoch in seconds, milliseconds or microseconds — guessed from its length — or as a date string.
-
Build the instant.
Whatever you typed is normalised to one absolute moment: milliseconds since the Unix epoch, timezone-free.
-
Render every form.
That instant becomes UTC, ISO 8601, the raw epoch in each unit, and the readable date and time.
-
Show relative & local.
Finally it adds your browser-local time and a human relative phrase like “3 hours ago”.
Epoch Reference
Which unit is that number?
For present-day timestamps the digit count gives the unit away. A quick cheat-sheet of epoch lengths, and the date forms the converter accepts.
Epoch lengths
Each step up multiplies by a thousand — so 10 digits is seconds, 13 is milliseconds, 16 is microseconds.
unit length example note
seconds 10 1700000000 classic Unix epoch
milliseconds 13 1700000000000 JS Date.now(), Java
microseconds 16 1700000000000000 Postgres, some traces
nanoseconds 19 1700000000000000000 Go time, perf countersDate examples
Feed it an epoch or a date string — ISO 8601, a plain date-time, or even now — and it resolves the same instant either way.
1700000000 → 2023-11-14T22:13:20Z
2023-11-14T22:13:20Z → 1700000000 (seconds)
2023-11-14 22:13:20 → parsed as local time
Nov 14 2023 22:13 UTC → 1700000000
now → current instantNext Step
Found that timestamp inside a token or a blob?
Epoch values rarely travel alone. If yours came out of a JSON Web Token, the JWT Decoder reads the iat and exp claims for you; if it was buried in an encoded payload, the Base64 Encoder / Decoder turns the blob back into readable text first.
"iat": 1700000000 → 2023-11-14T22:13:20Z
"exp": 1700003600 → 2023-11-14T23:13:20Z
expires in 1 hourFAQ
Questions, answered.
Tap a question to expand the answer.
What is Unix time?
Unix time — also called epoch time or POSIX time — is the number of seconds that have elapsed since the Unix epoch, 1970-01-01 00:00:00 UTC, not counting leap seconds. It is the most common way computers store an instant: a single integer, timezone-free, that every system can agree on. This converter turns that integer into a human-readable date and back again.
Seconds, milliseconds or microseconds — how do I tell them apart?
By length. A present-day epoch in seconds is 10 digits, in milliseconds 13 digits, and in microseconds 16 digits (nanoseconds reach 19). The converter detects the unit from the magnitude of the number — so 1700000000 is read as seconds and 1700000000000 as milliseconds — and you can override the guess if your data uses a different unit.
Does my timestamp ever leave my browser?
No. Parsing, the epoch maths and all the formatting run 100% client-side in your tab — there is no server, no account and no logging. You can safely paste timestamps from internal logs and private systems.
How does it handle time zones and daylight saving?
An epoch is an absolute instant, so the underlying moment never changes — only how it is rendered. The converter always shows the canonical UTC value alongside your browser local time, and the local rendering reflects your machine's time zone and its daylight-saving rules at that instant via the built-in Intl APIs. Switch machines or zones and the UTC line stays put while the local line shifts.
What is ISO 8601 and why does it matter?
ISO 8601 is the international standard for writing dates and times as text — for example 2024-01-15T09:30:00Z, where the trailing Z means UTC. It sorts lexicographically, is unambiguous about order (year-month-day), and is what JSON APIs, logs and databases overwhelmingly expect. The converter emits a strict ISO 8601 string so you can paste it straight into a payload or query.
How do I convert an ISO 8601 date to a Unix timestamp?
Paste an ISO 8601 string such as 2026-06-11T00:00:00Z into the input and the converter returns the matching epoch value in both seconds and milliseconds. The format follows YYYY-MM-DDTHH:mm:ssZ where Z denotes UTC; offsets such as +05:30 are also accepted. Conversion is bidirectional, so you can go from epoch to ISO 8601 or from ISO 8601 back to epoch.
How do I convert a 13-digit millisecond timestamp to a date?
Paste the 13-digit value directly and the converter recognises it as a milliseconds epoch automatically. Internally it divides by 1000 to get the underlying second and then formats the result as UTC, local time, ISO 8601 and a relative phrase. This matches the value produced by JavaScript Date.now() and Java System.currentTimeMillis().
What is the current unix timestamp right now?
The current Unix timestamp is the number of seconds that have elapsed since 1 January 1970 UTC at this exact moment. The converter displays the live value in both seconds and milliseconds, updated in real time in your browser. Most server-side APIs and SQL databases work in seconds, while JavaScript and browser analytics code typically use milliseconds.
How do I convert a date back to an epoch timestamp?
Enter any human-readable or ISO 8601 date string and the converter returns the corresponding Unix epoch value in seconds and milliseconds. Inputs such as 2024-01-15T09:30:00Z and similar formats are all accepted. The result is ready to paste into an API call, a database query, or a JWT claim.
More free, private DevOps tools.
The Timestamp Converter is one tool in OpsCanopy — a growing canopy of browser-based validators, converters and testers that never touch a server.
29 free tools, every one offline-capable — opscanopy.com works with no signup and nothing uploaded.
More encoding: the JWT Decoder and the Base64 Encoder / Decoder, or browse the full tools directory.
Provided as-is for convenience; always confirm critical time-sensitive values against an authoritative clock. OpsCanopy is free and open.