Timestamp Converter

Convert Unix timestamps to human-readable dates and vice versa. Supports seconds, milliseconds, microseconds and nanoseconds. Shows UTC and local time. Free, browser-based.

  • Runs in your browser
  • Tool input is not uploaded to ZeroTool servers
  • Free · No Sign-Up

Timestamp → Date

Auto unit counts integer digits: up to 12 means seconds, 13–15 milliseconds, 16–18 microseconds, and 19 or more nanoseconds. Choose a unit to override this. Sub-millisecond digits are discarded. Changing the unit converts nonempty input immediately.
Convert the timestamp after editing it, or press Enter in its field. Ctrl/⌘+Enter also runs this action. Results show Unix seconds, milliseconds, ISO 8601, UTC and the browser’s local time.
Fill the timestamp with the current time and convert it. Seconds and Auto unit use whole seconds; milliseconds retain the current millisecond value. Microseconds and nanoseconds append zeros without adding clock precision.
Enter decimal digits with an optional sign and fraction. Spaces around the value are ignored, and full-width digits, signs and decimal points are read as ASCII. Exponents, hexadecimal and thousands separators are rejected. Dates must fall within ±8,640,000,000,000,000 milliseconds of the epoch.

Date → Timestamp

Select a local date and time. Results update when the value changes, using your browser’s time zone. The same selection can represent a different instant on a computer in another zone.
Examples, details and FAQ Worked examples, how it compares with other tools, and answers to common questions.

About Unix Timestamps

The Unix epoch began at 1970-01-01 00:00:00 UTC. Every moment in time is stored as an integer offset from that point. Most systems use seconds; JavaScript uses milliseconds.

The 32-bit signed timestamp will overflow (the Year 2038 problem) on January 19, 2038. Modern 64-bit systems are not affected.

Examples

With the unit set to Auto unit, the converter counts the digits before any decimal point: up to 12 digits are seconds, 13–15 milliseconds, 16–18 microseconds, and 19 or more nanoseconds. Present-day values have 10, 13, 16 and 19 digits. The status line says which unit it used; choose a unit from the list to override it.

InputRead asISO 8601 (UTC)
1700000000seconds2023-11-14T22:13:20.000Z
1700000000123milliseconds2023-11-14T22:13:20.123Z
2147483647seconds2038-01-19T03:14:07.000Z
1700000000123456microseconds2023-11-14T22:13:20.123Z
1700000000123456789nanoseconds2023-11-14T22:13:20.123Z

2147483647 is the largest value a signed 32-bit integer can hold, which is where the Year 2038 problem starts. The last two rows are a microsecond timestamp (Python time.time_ns() // 1000, PostgreSQL internals) and a nanosecond one (Go time.Now().UnixNano(), date +%s%N); digits below the millisecond are dropped, because a JavaScript date holds whole milliseconds. Nanosecond values are larger than 253, so the tool reads them as big integers instead of floating-point numbers.

What each result row means

Converting 1700000000 gives five rows:

RowValueNotes
Unix (s)1700000000Whole seconds, rounded down
Unix (ms)1700000000000What Date.now() and Java System.currentTimeMillis() return
ISO 86012023-11-14T22:13:20.000ZAlways UTC (Z) with milliseconds, from Date.prototype.toISOString
UTCTue, 14 Nov 2023 22:13:20 GMTThe HTTP date format of RFC 9110 §5.6.7, used in Date, Expires and Last-Modified headers
Local (UTC+09:00)2023-11-15 07:13:20Your computer's time zone; the label shows its offset on that date (here Tokyo)

Date to Timestamp across time zones

The date picker has no time zone field, so the same wall-clock time gives different timestamps on different computers. Picking 2026-01-01 09:00:00 returns 1767225600 (2026-01-01T00:00:00.000Z) on a computer set to Asia/Tokyo, and 1767276000 (2026-01-01T14:00:00.000Z) on one set to America/New_York. The ISO 8601 row shows which instant you actually selected. To work with a zone other than your own, use the Timezone Converter.

Daylight saving time skips an hour in some zones. In America/New_York, clocks jump from 02:00 to 03:00 on the second Sunday in March (Rule US 2007 max Mar Sun>=8 2:00 in the tz database), so 02:30 on 2026-03-08 does not exist there. Picking 2026-03-08 02:30:00 on a computer set to that zone still converts, using the offset from before the jump: the result is 1772955000 (2026-03-08T07:30:00.000Z), and the Local (UTC-04:00) row shows 2026-03-08 03:30:00, not the time you picked. That reading follows the UTC(t) operation in ECMA-262 §21.4.1.26.

Accepted input

The timestamp field takes decimal digits with an optional + or - sign and an optional decimal part. Spaces around the value are ignored, and full-width digits, signs and decimal points typed with a Chinese, Japanese or Korean input method are read as ASCII; the field keeps what you typed.

  • Negative values are dates before 1970: -86400 is 1969-12-31T00:00:00.000Z.
  • A decimal part adds milliseconds: 1700000000.5 gives 1700000000500.
  • The full-width 1700000000 gives the same 2023-11-14T22:13:20.000Z as 1700000000.
  • Exponent notation is rejected: 1e9 gives “Invalid timestamp. Enter digits with an optional sign and decimal point. For a date, use Date → Timestamp.”
  • Dates as text, such as 2024-05-01, get the same message. Use the date picker for those.

Do It in Code

date +%s                      # current timestamp (Linux, macOS)
date -u -d @1700000000        # GNU date (Linux)
date -u -r 1700000000         # BSD date (macOS)
Math.floor(Date.now() / 1000)          // current timestamp in seconds
new Date(1700000000 * 1000).toISOString()  // "2023-11-14T22:13:20.000Z"
import time, datetime
int(time.time())                                                  # current timestamp
datetime.datetime.fromtimestamp(1700000000, datetime.timezone.utc)  # 2023-11-14 22:13:20+00:00

Limits

  • Automatic unit by length only. A millisecond value from before 2001-09-09 has 12 digits and is read as seconds, and a seconds value of 13 digits or more (after year 33658) is read as milliseconds. Choose the unit in those cases.
  • Digits only. Exponents (1e10), hexadecimal and thousands separators are rejected; a decimal part is accepted. Full-width digits are read as ASCII, but other digit sets, such as Arabic-Indic digits, are rejected.
  • Date to Timestamp uses your local time zone. The date picker value is read in your browser's time zone, so the same picker value gives different timestamps on computers set to different zones.
  • No leap seconds. Unix time ignores leap seconds, as does JavaScript's Date.
  • Range. JavaScript dates cover ±8,640,000,000,000,000 ms from the epoch, about 273,790 years each way (ECMA-262 §21.4.1.1). With the unit set to milliseconds, 8640000000000000 converts to +275760-09-13T00:00:00.000Z; one more millisecond gives "Timestamp out of range."

FAQ

What is a Unix timestamp?

A Unix timestamp (also called Epoch time) is the number of seconds elapsed since January 1, 1970 00:00:00 UTC. Many systems count milliseconds instead, such as JavaScript's Date.now(), and some count microseconds or nanoseconds.

Seconds or milliseconds — how do I tell?

A 10-digit number is almost certainly seconds (valid until 2286). A 13-digit number is milliseconds, 16 digits microseconds and 19 digits nanoseconds. This tool counts the digits before any decimal point (up to 12 means seconds), shows which unit it used, and lets you choose the unit.

Which time zone does the local result use? Can I pick another?

Your browser's time zone. The ISO 8601 and UTC rows show the instant in UTC; the Local row shows it in your zone, and its label gives that zone's offset on that date, including daylight saving time, from the browser's time zone data. Date → Timestamp reads the picked date and time in the same zone. There is no zone selector; to convert between other zones, use the Timezone Converter.

What happens to a time that daylight saving time skips?

Date → Timestamp reads a skipped local time with the offset in force before the change, as the UTC(t) operation of ECMAScript specifies. On a computer set to America/New_York, 2026-03-08 02:30:00 gives 1772955000, and the Local row shows 2026-03-08 03:30:00. A time that occurs twice when clocks go back, such as 2026-11-01 01:30:00, is read as the earlier instant, 1793511000.

Is any data sent or saved?

No. Timestamps and dates are converted in your browser; they are not uploaded and not saved in browser storage. Usage statistics record only the tool name and the action, once for each new Timestamp → Date result, whether it comes from Convert, Enter, Ctrl/⌘+Enter, Now or a unit change; the same result again is not counted. They do not include the value.