Convert Unix timestamps in seconds or milliseconds to a readable date, or convert a date to Unix time. Compare UTC and supported time zones in your browser.
Unix time identifies an instant; a time zone controls how that instant is displayed. Check seconds versus milliseconds before comparing the UTC, ISO and city-time results. A different time-zone display does not represent a different underlying instant.
Check the unit before interpreting a timestamp as a calendar date.
The millisecond representation is 1,000 times the second value. These modern timestamps are detected by input length; check the ISO result rather than assuming every numeric value was interpreted in your intended unit.
The +01:00 offset puts this local clock reading one hour ahead of UTC, so it represents the same instant as midnight UTC. A date without an offset can be interpreted using your browser’s local zone.
The second value is one thousand times the first because it uses milliseconds. Z denotes UTC; a city-time display applies that location’s offset.
Use a complete ISO date with Z or a numeric offset for repeatable results. Changing the display time zone changes the clock representation, not the underlying instant. Use complete numeric timestamp values. A displayed local time and a UTC time can look different while identifying the same instant.
The Timestamp & Time-Zone Converter is a precision temporal calculation and formatting utility that transforms Unix epoch timestamps (seconds and milliseconds) into ISO-8601 strings, UTC representations, and IANA timezone dates. Using JavaScript Date and Intl.DateTimeFormat, the tool provides instant time conversions for developers, DevOps engineers, database administrators, and global teams.
Unix time measures elapsed seconds since 00:00:00 UTC on January 1, 1970 (the Unix Epoch). Unix timestamps do not count leap seconds. Time-zone and daylight-saving offsets affect the displayed local clock time, not the underlying instant. This tool displays seconds and milliseconds, human-readable relative durations (e.g. "3 hours ago"), and formats outputs across the listed time zones (New York, London, Tokyo, Sydney, UTC).
The tool also includes an interactive Multi-Timezone Meeting Comparator, allowing distributed remote teams to evaluate overlap windows across global business hours without manual timezone math. Date conversions run in your browser; the site may separately use analytics.
Type or paste a Unix timestamp in seconds (10 digits) or milliseconds (13 digits), or an ISO-8601 string in the separate date-time input. Use an explicit Z or offset for unambiguous dating.
View the instant breakdown into ISO-8601 (UTC), a UTC date string, relative duration, and epoch seconds/milliseconds.
Review the global timezone matrix displaying current local times across major financial and tech hubs with the browser’s applicable time-zone and daylight-saving offsets.
Click a result card to copy its ISO string or Unix seconds/milliseconds, or use a city’s copy button for its formatted local date.
Accepts modern Unix timestamps in seconds or milliseconds and ISO-8601 date-time strings. Microseconds are not supported directly; divide a microsecond timestamp by 1,000 before entering milliseconds.
Calculates exact local times across standard IANA timezones (America/New_York, Europe/London, Asia/Tokyo, etc.) with DST compensation.
Computes humanized temporal distances ("5 minutes ago", "in 2 days", elapsed hours/minutes) relative to the current clock.
Executes all date-time arithmetic using high-performance browser JavaScript datetime engines with zero network latency.
Unix timestamps are often supplied in seconds, while JavaScript dates commonly use milliseconds. Mixing the two produces a dramatically wrong date. A timestamp represents an instant; the displayed clock time depends on the chosen zone. For recurring meetings, daylight-saving transitions require checking each actual calendar date.
Debug database timestamps (PostgreSQL, MongoDB, MySQL), JWT token expiration timestamps (exp/iat), and API log event times.
Analyze server crash logs, distributed trace timestamps, and CI/CD pipeline event chronologies across global server regions.
Coordinate meeting schedules across disparate international timezones without miscalculating Daylight Saving Time shifts.
Normalize mixed timestamp formats from CSV dataset exports into standardized ISO-8601 datetime strings.
| Input or option | Reference | What to check |
|---|---|---|
| Unix seconds | Seconds since 1970-01-01T00:00:00Z | Modern values usually have about ten digits |
| Unix milliseconds | 1000 milliseconds per second | Use the matching input unit |
| Time zone | Local representation of an instant | Does not change the underlying instant |
Paste the value into Unix Epoch Timestamp (Seconds or Milliseconds), then read the UTC ISO String or a city in the time-zone comparison. For example, 1704067200 seconds and 1704067200000 milliseconds both represent January 1, 2024 at 00:00:00 UTC. Here, real time means a readable calendar date and clock time; a timestamp identifies an instant, not a duration.
Enter the Unix value in the timestamp field, then read the UTC and ISO results or the supported city-time displays. For example, 1700000000 seconds corresponds to 2023-11-14 at 22:13:20 UTC. The same instant is 1700000000000 milliseconds. A local clock reading can fall on a different calendar date because its time-zone offset differs.
Enter a date-time in ISO 8601 Date / Time String with an explicit zone, such as 2024-01-01T00:00:00Z. Read Unix Seconds (1704067200) or Unix Milliseconds (1704067200000). Z means UTC; an offset such as +05:30 also identifies the instant. A date-time without a zone can be interpreted in your browser’s local time, so include the zone when sharing or debugging dates.
A 10-digit timestamp represents Unix time in seconds (e.g. 1718000000), which is standard in Unix/Linux systems and C/Python libraries. A 13-digit timestamp represents Unix time in milliseconds (e.g. 1718000000000), which is the native format used in JavaScript (Date.now()) and Java.
The tool uses the browser native Intl.DateTimeFormat API referencing the official IANA Time Zone Database (tzdata). It automatically applies exact historical and current Daylight Saving Time offsets for each specific geographic timezone.
ISO-8601 (e.g. 2026-06-10T14:30:00.000Z) is the international standard for representing dates and times. It eliminates ambiguity across international date formats (MM/DD/YYYY vs DD/MM/YYYY) and includes explicit timezone offsets, making it the gold standard for JSON APIs and SQL databases.
Some systems store Unix seconds as a signed 32-bit integer, which overflows after 2,147,483,647 seconds on January 19, 2038. JavaScript Date is not limited to that 32-bit seconds range, but it still has a finite supported range. Converting a date here does not fix a database or application that stores timestamps in a 32-bit field.
Click Set to Now to refresh the inputs to the current instant, then click the Unix Seconds or Unix Milliseconds result to copy it. The selected timestamp stays fixed until you change an input or click Set to Now again; it is not a continuously ticking clock.
An internet connection is required to open tools and refresh a temporary session. Processing stays on your device; the handshake sends a random challenge, not files or text inputs. Libraries, fonts or models may download. Local processing cannot remove risks from an untrusted device or extension.
For timestamps in the same unit, subtract the earlier value from the later value. A difference of 3600 seconds is one hour; a difference of 3600000 milliseconds is also one hour. This page converts one timestamp at a time, so compare each instant here and calculate the difference separately. Do not subtract a seconds value directly from a milliseconds value.
