← Guides

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).

timestamp to dateunix timestamp converterepoch to dateconvert timestampseconds vs milliseconds

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

Input
1700000000
Output
2023-11-14 22:13:20 UTC

IST is 2023-11-15 03:43:20. → Date on /tools/timestamp prints your local equivalent of this UTC instant.

New Year 2024 UTC

Input
1704067200
Output
2024-01-01 00:00:00 UTC

JavaScript would store 1704067200000 ms. JWT exp should keep the 10-digit second form.

Y2K in seconds

Input
946684800
Output
2000-01-01 00:00:00 UTC

Nine 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.

Try it yourself

Put what you've learned into practice with our free browser-native tool.

Open Tool →