esc

Unix Timestamp Converter

Convert Unix timestamp to date, date to epoch, ISO 8601, UTC and local time zones instantly in your browser.

Now — —
Unit
Valid
Result
Across time zones
Same instant
Guide

Understanding Unix time

A Unix timestamp is the number of seconds that have elapsed since the Unix epoch — 00:00:00 UTC on 1 January 1970 — not counting leap seconds. It is the standard way computers store an instant in time: a single integer that is unambiguous, timezone-free and trivial to compare or sort. This Unix timestamp converter turns epoch seconds, milliseconds or microseconds into calendar dates and can convert dates back to epoch values.

The same instant can be written at different resolutions: seconds (10 digits today), milliseconds (13 digits, common in JavaScript and Java), or microseconds (16 digits). This tool auto-detects the unit from the magnitude, or you can force it. Results include local time, UTC, ISO 8601 and the same instant across time zones. Conversion happens entirely in your browser using your device's clock and time-zone database — nothing is uploaded.

Reference

Notable Unix timestamps

Values that show up in logs, tests and bug reports. Click a value to convert it, or read the guide.

0 1970-01-01 00:00:00 UTC The Unix epoch
1000000000 2001-09-09 01:46:40 UTC The Unix billennium
1234567890 2009-02-13 23:31:30 UTC Friday the 13th
2147483647 2038-01-19 03:14:07 UTC Year 2038 problem
Examples

Unix timestamp conversion examples

The same instant can arrive in many shapes. These inputs all go into the single box at the top of the page; the second column is how Auto mode reads them, and the last column is the ISO 8601 · UTC value the converter shows.

Input Read as ISO 8601 (UTC)
1700000000 Unix seconds (10 digits) 2023-11-14T22:13:20.000Z
1700000000000 Unix milliseconds (13 digits) 2023-11-14T22:13:20.000Z
1700000000000000 Unix microseconds (16 digits) 2023-11-14T22:13:20.000Z
-86400 Unix seconds, one day before the epoch 1969-12-31T00:00:00.000Z
2026-06-09T12:00:00Z Date string → 1781006400 Unix seconds 2026-06-09T12:00:00.000Z
2026-06-09T14:00:00+02:00 Date string with offset → 1781006400 2026-06-09T12:00:00.000Z

The last two rows are the same instant written with different offsets, so they produce the same epoch value. As you type, the converter also writes your input into the page address as ?ts=, so a link such as /tool/timestamp?ts=1700000000 reopens the same conversion for a colleague — who will see it in their own local time zone.

Reading results

How to read the converter output

  • ISO 8601 · UTC — the timezone-free reference, always ending in Z and including milliseconds. This is the value Copy ISO 8601 copies.
  • Local time — the instant formatted in your browser's time zone; the zone name is shown underneath.
  • UTC (RFC 1123) — the format used in HTTP headers such as Date and Expires, for example Tue, 14 Nov 2023 22:13:20 GMT.
  • Relative — "in 3 days" or "5 hours ago", measured against your device clock.
  • Unix · seconds and Unix · milliseconds — the instant in both common resolutions. Seconds are rounded down, so a millisecond input of 1700000000999 shows 1700000000 seconds.

The line under the result tiles adds the weekday, day of year, ISO week (for example 2023-W46), quarter and whether the year is a leap year. These are all calculated in UTC, so for an instant close to midnight they can differ from your local calendar date. The Across time zones panel shows the same instant in your zone plus UTC, Los Angeles, New York, São Paulo, London, Berlin, Kolkata, Shanghai, Tokyo and Sydney, with the UTC offset that applied at that moment — so daylight saving time is reflected per date, not as a fixed offset.

Use cases

Common uses for an epoch converter

  • Reading logs and metrics. Paste an epoch value from a log line or a monitoring export to see when an event happened in your time zone and in UTC.
  • Checking token lifetimes. JWT claims such as exp, iat and nbf are Unix seconds. Convert them here, or decode the whole token with the JWT Decoder.
  • Writing test fixtures and database values. Pick a date with the date picker, choose Local time or UTC, and copy the resulting seconds or milliseconds.
  • Planning scheduled jobs. Check what a server's UTC time corresponds to locally before writing a schedule in the Cron Expression Generator.
  • Inspecting API payloads. Timestamps inside JSON are easier to read once the response is formatted with the JSON Formatter.
Troubleshooting

Timestamp troubleshooting

The date lands in January 1970

A seconds value is being read as milliseconds. For example, 1700000000 forced to ms becomes 1970-01-20T16:13:20.000Z. Switch the unit back to Auto or s. The same mistake in code usually means a missing * 1000 before passing seconds to JavaScript's Date.

The year is tens of thousands of years in the future

The value is probably in nanoseconds (19 digits, common in Go and some tracing systems). Auto mode only goes up to microseconds, so a nanosecond value is read as microseconds and lands around the year 55,800. Remove the last three digits and convert again.

The time is off by a few hours

A date string without an offset, such as 2026-06-09T12:00:00, is read as your local time, while a date-only string such as 2026-06-09 is read as midnight UTC — this is how the browser's date parser works. Add Z or an explicit offset like +02:00 to remove the ambiguity. With the date picker, check whether Local time or UTC is selected.

"Couldn't parse"

Epoch values must be whole numbers with an optional minus sign. Remove thousands separators and spaces, and convert fractional seconds to milliseconds first ( 1700000000.5 → 1700000000500 ). For dates, ISO 8601 is the most reliable format; other formats depend on what your browser's date parser accepts.

Limitations

What this timestamp converter does not do

  • Millisecond resolution. Conversion uses the JavaScript Date object, which stores whole milliseconds. Microsecond input is accepted, but the last three digits are dropped in the results.
  • No nanosecond unit and no leap seconds. Like Unix time itself, results ignore leap seconds.
  • Limited range. Date covers about 273,000 years either side of 1970 (up to the year 275760); values beyond that are reported as out of range.
  • Your device's clock and time-zone data. The "Now" bar and relative times come from your device clock, and offsets come from your browser's time-zone database, which may be out of date for recently changed zone rules or uncertain for historical dates.

For a deeper explanation of seconds versus milliseconds, time zones, daylight saving time and the year 2038 problem, read the guide Unix Timestamps Explained, especially debugging an unknown timestamp.

FAQ

Frequently asked questions

How do I convert Unix timestamp to date?

Paste an epoch value and the converter shows local time, UTC, ISO 8601, and the same instant across major time zones. Auto mode detects seconds, milliseconds, or microseconds by magnitude.

Seconds or milliseconds - how does Auto decide?

A present-day Unix timestamp is 10 digits in seconds and 13 digits in milliseconds. Values of 10^12 or more are read as milliseconds, and 10^15 or more are read as microseconds.

Which time zone are the results in?

Local time uses your browser time zone. UTC and ISO 8601 are always shown as stable references, and the time-zone panel shows the same instant in several cities.

Is my timestamp data sent anywhere?

No. Every conversion runs client-side using the browser Date and Intl APIs. Nothing you type is uploaded.

What is the year 2038 problem?

Systems that store Unix time in a signed 32-bit integer overflow at 03:14:07 UTC on 19 January 2038. Modern 64-bit timestamp systems are unaffected.