Developer Guide
Convert Timestamp to Date
Turn Unix epoch seconds into a readable date. Covers the 10-digit vs 13-digit heuristic, local timezone display, and IST (UTC+5:30).
A Unix timestamp is a count of seconds since 1970-01-01 00:00:00 UTC. The number has no timezone inside it. 1700000000 is always the same instant: 2023-11-14 22:13:20 UTC. What changes is how you print that instant — UTC, the browser’s local zone, or IST.
/tools/timestamp in → Date mode takes seconds and formats them with Intl.DateTimeFormat in your local timezone, including a short zone name. This page is that direction: number in, calendar out. Building a timestamp from a picker, Use Now, Y2038, and JWT exp belong on the date-to-timestamp guide.
Seconds since the epoch
1704067200 is 2024-01-01 00:00:00 UTC. 946684800 is 2000-01-01 00:00:00 UTC. Current dates use ten digits. Paste the integer into /tools/timestamp, stay on → Date, and read the formatted line. The tool multiplies by 1000 only to construct a JavaScript Date; it does not want milliseconds in the box.
Click Use Now to fill the current second count, then convert, when you need a sanity check against a log line that should be “about now.”
Ten digits versus thirteen: the millisecond heuristic
POSIX, most databases, and JWT exp / iat / nbf use seconds (ten digits for dates after September 2001). JavaScript Date.now() uses milliseconds (thirteen digits). If you paste 1700000000000 into a seconds converter, you are asking for a date around the year 56,000.
Heuristic: 10 digits → treat as seconds; 13 digits → divide by 1000 and floor before pasting into /tools/timestamp. Values around 9 digits are the 1990s and early 2000s in seconds (946684800 is Y2K). Do not round-trip milliseconds through JWT claims.
What “timezone” means on the result
The stored integer is UTC. The human-readable line is not. /tools/timestamp formats in the timezone of the machine running the browser, via timeZoneName: short. On a US Pacific clock, 1700000000 shows an afternoon local time; on a UTC clock it shows 10:13:20 PM.
That is display, not conversion of the number. Two people converting 1700000000 should agree it is 2023-11-14 22:13:20 UTC even if their formatted strings differ. When a ticket says “the timestamp is wrong,” check whether someone compared a local clock to a UTC log.
India Standard Time without DST
IST is UTC+5:30 all year — India does not observe daylight saving. 1700000000 is 2023-11-15 03:43:20 IST. 1704067200 is 2024-01-01 05:30:00 IST, not midnight in Mumbai.
/tools/timestamp-ist exists so you do not add 19800 seconds by hand in five SQL snippets. Convert seconds → IST there when the audience is in India; keep /tools/timestamp for local-browser display and for the → Timestamp direction.
Logs, APIs, and JWT claims
Log processors often print epoch seconds. APIs return them as JSON numbers. JWTs store exp as NumericDate seconds. If /tools/jwt-debugger shows exp as thirteen digits, the issuer used Date.now() without dividing by 1000 — that token is not “a bit skewed”; the unit is wrong.
Convert the claim on /tools/timestamp after you confirm it is ten digits. Do not multiply a seconds field by 1000 and also pass it to a seconds converter.
Common pitfalls
Pasting milliseconds into → Date is the bug that looks like a far-future date. Comparing a local formatted string to a UTC ISO string is the bug that looks like a five-hour offset in India or an eight-hour offset on the US west coast in winter.
Another trap: treating the formatted output as something you can parse back with Date.parse across locales. Copy the integer, not the English sentence, if you need to move the value.
1700000000= 2023-11-14 22:13:20 UTC.- 13-digit values are milliseconds — divide by 1000 first.
- IST display is
/tools/timestamp-ist(UTC+5:30, no DST).
Worked examples
A well-known 10-digit instant
17000000002023-11-14 22:13:20 UTCIST is 2023-11-15 03:43:20. → Date on /tools/timestamp prints your local equivalent of this UTC instant.
New Year 2024 UTC
17040672002024-01-01 00:00:00 UTCJavaScript would store 1704067200000 ms. JWT exp should keep the 10-digit second form.
Y2K in seconds
9466848002000-01-01 00:00:00 UTCNine or ten digits around here are still seconds, not milliseconds.
Frequently asked questions
Does the converter expect milliseconds?
No. /tools/timestamp is seconds. If you have Date.now(), divide by 1000 and floor. Thirteen digits in the box are almost always the wrong unit.
Why does my result not match UTC?
→ Date formats in the browser’s local zone. The integer is still UTC. Compare against 2023-11-14 22:13:20 UTC for 1700000000, or use /tools/timestamp-ist for India.
How do I convert to IST?
/tools/timestamp-ist applies UTC+5:30 with no DST. Do not add 19800 in application code in some places and not others.
My JWT looks expired in every timezone.
Check the digit count. exp is Unix seconds. A 13-digit exp is milliseconds stuffed into a seconds field. Inspect the token on /tools/jwt-debugger.
Is the conversion uploaded?
No. The integer stays in your browser. Use Now also reads Date.now() locally.
Summary
Read a Unix timestamp as seconds, split 10-digit from 13-digit values before you paste, and remember the formatted date is local while the integer is UTC. /tools/timestamp → Date handles the general case; /tools/timestamp-ist prints UTC+5:30. To go the other way — picker to epoch — use the date-to-timestamp guide.