Skip to content
Time helper

UNIX Time Converter

Convert UNIX timestamps (seconds or milliseconds) to UTC/local time and back.
The tool auto-detects whether the input is 10-digit seconds or 13-digit milliseconds
and updates all fields in real time with no API calls.

View ISO 8601 output, human-readable strings, and the detected weekday.
Quick actions let you copy any field, jump to the current time, auto-refresh every second, or clear inputs.
All calculations are done in your browser using the native Date and Intl APIs.

Pick any time zone for display and input, read microsecond and nanosecond timestamps, paste ISO 8601 or RFC 2822 dates, see the relative time and the HTTP date, and convert many timestamps at once.

Auto-detects seconds or milliseconds

Auto-syncs with UNIX input. Accepts local time.

e.g. 2025-07-01T15:00:00Z, Tue, 01 Jul 2025 15:00:00 GMT, or 2025-07-01 15:00 (read in the selected time zone)

Converted values
Auto-detects seconds or milliseconds
UNIX (seconds)
0
UNIX (milliseconds)
0
ISO 8601 (UTC)
1970-01-01T00:00:00.000Z
UTC (human readable)
1970-01-01
Local time (selected zone)
1970-01-01
RFC 2822
-
HTTP date (GMT)
-
UNIX (microseconds)
0
UNIX (nanoseconds)
0
Relative to now
-

Convert many timestamps at once

Paste one UNIX timestamp per line (seconds, milliseconds, microseconds or nanoseconds).

Date math

Computed in the time zone selected above. Months and years are not fixed lengths, so durations use days at most.

Guide

How to use & features

  • 10 digits are treated as seconds, 13 digits as milliseconds automatically.
  • Editing the date/time field keeps the UNIX timestamp in sync.
  • Use the copy buttons to quickly grab any value for logs or scripts.
Samples

Sample input & output

Get UNIX time from ISO date

Input
2024-02-01T00:00:00Z
Output
1706745600
FAQ

FAQ

  • How does it tell seconds from milliseconds?

    Input of 12 digits or more is treated as milliseconds; shorter input is seconds. For example `1700000000` (10 digits) is seconds and `1700000000000` (13 digits) is milliseconds.
  • What date is `1700000000`?

    2023-11-14 22:13:20 UTC, which is 2023-11-15 07:13:20 in Japan time (JST). In ISO 8601 it is shown as `2023-11-14T22:13:20.000Z`.
  • What is the difference between UTC and local time?

    UNIX time counts elapsed time from 1970-01-01 00:00:00 UTC and does not depend on region. "Local" is the same instant shown in your browser's time zone.
  • Can I get UNIX time from a date and time?

    Yes. Pick a date and time in the date input and the UNIX time in seconds and milliseconds appears. The input is treated as the browser's time zone.
  • Does it handle dates before 1970 (negative values)?

    Yes. A negative value such as `-86400` gives 1969-12-31.
  • Does the year 2038 problem affect it?

    No. JavaScript stores time as 64-bit floating-point milliseconds. The 2038 problem concerns older systems that store seconds in a signed 32-bit integer.
Use cases

Common use cases

  • Turning log and DB timestamps into dates

    Convert values such as `1700000000` in logs or a `created_at` column into readable dates, in both UTC and local time, and see when something happened.
  • Checking a JWT `exp` or `iat`

    A JWT's expiry (`exp`) and issued-at (`iat`) are UNIX time in seconds. Paste the value to see when the token expires.
  • Creating timestamps for tests

    Pick a date and time, copy the UNIX time in seconds or milliseconds, and use it directly in test data or API requests.
  • Aligning times during incident investigation

    Show UNIX-time logs from separate systems in both UTC and local notation so you can match up the timeline.
Notes

Notes & limitations

  • Seconds, milliseconds, microseconds and nanoseconds are decided by digit count

    Up to 11 digits is read as seconds, 12 to 14 as milliseconds, 15 to 17 as microseconds and 18 or more as nanoseconds. A small millisecond value from before March 1973 (11 digits or fewer) is read as seconds, so check the digit count when a result looks wrong.
  • Local means the time zone you choose

    Output and date input follow the time zone you select, which starts as your browser time zone. The UTC display does not change whichever zone you pick.
  • The range is limited

    Values beyond JavaScript's date range (about 270,000 years either side of 1970) cannot be converted to a date.
  • Leap seconds are not counted

    As in the definition of UNIX time, a day is always 86,400 seconds.
About

About this tool

Unix Timestamp Converter

Unix timestamps appear in logs, databases, API responses, JWT claims, analytics exports, and monitoring alerts. This converter turns second-based or millisecond-based timestamps into readable dates and helps you convert dates back into timestamp values.

Common use cases

  • Debug logs: Convert raw timestamps into human-readable times during incident investigation.
  • Check API fields: Review created_at, updated_at, iat, exp, and expiration values.
  • Validate stored data: Confirm whether database timestamps match expected user actions or system events.

Seconds vs milliseconds

A 10-digit timestamp is often seconds, while a 13-digit timestamp is often milliseconds, but systems vary. If the resulting date looks far in the past or future, check whether you are using the correct unit.

Articles for this tool

Recent Articles