Unix Timestamp Converter

How to use it

Current Unix time shows your device’s clock in seconds and ticks every second. Now puts it in the input; Copy copies it.

1. Type into Timestamp or date: a Unix timestamp in seconds, milliseconds, microseconds or nanoseconds, an ISO 8601 date like 2024-03-10T02:30:00Z, or an email or HTTP date like Sun, 06 Nov 1994 08:49:37 GMT.
2. Pick a Timezone. It starts on your browser’s zone, with UTC first in the list.

The first line of the result is the date and time in that zone, with its UTC offset at that moment. The table lists Seconds, Milliseconds, ISO 8601 (UTC), Day of the week (in the chosen zone), Read as (the unit the tool picked) and Relative to now. Notes under it flag a daylight saving gap or overlap, the 2038 limit, digits the ISO time drops, or a wrong day of the week. It runs in your browser; nothing is uploaded.

Examples

Run with now fixed at 2026-10-14T12:00:00Z, which only affects Relative to now.

A 10-digit timestamp, with Timezone set to America/New_York: 1700000000

2023-11-14 17:13:20 America/New_York (UTC-05:00)
Seconds           1700000000
Milliseconds      1700000000000
ISO 8601 (UTC)    2023-11-14T22:13:20.000Z
Day of the week   Tuesday
Read as           seconds since the epoch
Relative to now   3 years ago

With Europe/Kyiv it’s 2023-11-15 00:13:20, a Wednesday, already the next day.

A local time with no offset on the night New York springs forward, with America/New_York: 2024-03-10T02:30:00

2024-03-10 03:30:00 America/New_York (UTC-04:00)
Seconds           1710055800
Milliseconds      1710055800000
ISO 8601 (UTC)    2024-03-10T07:30:00.000Z
Day of the week   Sunday
Read as           a date, not a timestamp
Relative to now   3 years ago

The note reads America/New_York skips 02:30 on 2024-03-10: the clocks jump forward, so this reads as 03:30 local.

An HTTP Last-Modified header value, with UTC: Sun, 06 Nov 1994 08:49:37 GMT

1994-11-06 08:49:37 UTC (UTC+00:00)
Seconds           784111777
Milliseconds      784111777000
ISO 8601 (UTC)    1994-11-06T08:49:37.000Z
Day of the week   Sunday
Read as           a date, not a timestamp
Relative to now   32 years ago

A nanosecond timestamp from Go’s time.Now().UnixNano(), with UTC: 1700000000123456789

2023-11-14 22:13:20 UTC (UTC+00:00)
Seconds           1700000000.123456
Milliseconds      1700000000123.456
ISO 8601 (UTC)    2023-11-14T22:13:20.123Z
Day of the week   Tuesday
Read as           nanoseconds since the epoch
Relative to now   3 years ago

Every digit is read exactly; the note says the ISO time stops at milliseconds, the rest at microseconds.

A date that doesn’t exist, 2024-02-30T10:00:00Z, is rejected with February 2024 has 29 days, so 30 isn't one of them.

Good to know

• Unix time is seconds since 1970-01-01T00:00:00Z, without leap seconds. POSIX counts every day as exactly 86,400 seconds, so 23:59:60 is rejected with There's no second 60; seconds run from 00 to 59. Negative numbers are before 1970: -1 is 1969-12-31T23:59:59.000Z.
• The unit comes from the number’s size. Up to 11 digits is seconds, 12 to 14 milliseconds, 15 to 17 microseconds and 18 to 20 nanoseconds, so 946684800000 is 2000-01-01 in milliseconds. The cut at 100000000000 is the year 5138 in seconds and 1973-03-03 in milliseconds, so older milliseconds read as seconds: enter those as an ISO date. Seconds may have a fraction, like time.time()’s 1792021963.2666938, kept to the microsecond.
• A date without an offset is read in the chosen Timezone. 2024-03-10 with America/New_York is 2024-03-10T05:00:00.000Z. JavaScript’s new Date("2024-03-10") would give midnight UTC instead. With Z or an offset like +05:30, the zone only changes the display. Digits past milliseconds are dropped.
• When clocks go back, a local time happens twice. The tool takes the first: 2024-11-03T01:30:00 in New York is -04:00. Write 2024-11-03T01:30:00-05:00 for the second.
• Email and HTTP dates follow RFC 5322, which HTTP’s IMF-fixdate (RFC 9110) is a subset of. The zone can be GMT, UT, UTC, a US zone like EST or PDT, or an offset like +0100. Two-digit years 00-49 mean 2000-2049 and 50-99 mean 1950-1999. The day of the week is optional but must match the date: Mon, 06 Nov 1994 gets a note that it’s a Sunday, and the date wins.
• A signed 32-bit time_t runs out at 2147483647, 2038-01-19T03:14:07Z. Instants past it, or before 1901-12-13T20:45:52Z, get a note.
• Relative to now rounds to the nearest whole unit, counting calendar months and years from now, and moves up a unit rather than say 12 months or 24 hours: on 2026-10-14, 2025-10-29 is 1 year ago.
• Input is limited to 200 characters, and numbers to 20 digits.

Questions

What is the current Unix time?

It’s the number under Current Unix time, and it’s the same everywhere on Earth at a given moment. In a shell, date +%s prints it; in JavaScript it’s Math.floor(Date.now() / 1000), and in Python int(time.time()).

How do I convert a Unix timestamp to a date?

Paste it into Timestamp or date and pick your timezone. In JavaScript, new Date(1700000000 * 1000).toISOString() returns 2023-11-14T22:13:20.000Z; Date takes milliseconds, hence the * 1000. On Linux, date -u -d @1700000000; on macOS, date -u -r 1700000000.

Is my timestamp in seconds or milliseconds?

Count the digits: between 2001 and 2286, seconds have 10 digits and milliseconds 13. JavaScript’s Date.now() and Java’s System.currentTimeMillis() return milliseconds; date +%s and PHP’s time() return seconds; Go’s UnixNano() returns nanoseconds, 19 digits. Python’s time.time() returns fractional seconds, which work too.

Does a Unix timestamp depend on the timezone?

No: a Unix timestamp names one instant and has no timezone. The zone only matters when you turn it into a date and time, so for a timestamp, changing Timezone changes the first line but never Seconds.