Skip to content

Unix timestamp converter

Turn a timestamp into a date, or a date into a timestamp.

Now

1794762285
1794762285909 ms

Read as Unix time in seconds.

Your files are open only in this tab. Nothing is uploaded.

Converted

Unix seconds
1794762285
Unix milliseconds
1794762285000
ISO 8601 (UTC)
2026-11-15T17:04:45.000Z
Your time zone
Sunday, November 15, 2026 at 5:04:45 PM UTC
UTC
Sun, 15 Nov 2026 17:04:45 GMT
Relative
1 second ago
Day of the year
319
ISO week
2026-W46

How to use Unix timestamp converter

  1. Enter a Unix timestamp or date string. Type or paste seconds, milliseconds, microseconds, nanoseconds, the word now, or a date into Timestamp or date.
  2. Use presets or the date picker. Click Now, In 24 hours, or Unix epoch to jump to common instants, or choose a calendar date under Pick a date and time.
  3. Select a target time zone. Switch the Time zone dropdown between your local IANA zone, UTC, or any global region.
  4. Copy any converted output. Click the copy button next to Unix seconds, Unix milliseconds, ISO 8601 (UTC), Relative, Day of the year, or ISO week.

Everything runs in this browser tab. Nothing you paste or open is uploaded or logged, so it's safe for keys, tokens and private data.

How does automatic epoch unit detection work?

The parser inspects the number of integer digits before any decimal point to infer whether a numeric input represents seconds, milliseconds, microseconds, or nanoseconds. This avoids forcing you to toggle unit dropdowns every time you switch between backend logs, browser events, and telemetry metrics.

Input digit count Detected unit Divisor to JS milliseconds Common source systems
1 to 11 digits Seconds Multiply by 1,000 POSIX time_t, JWT exp/iat, Linux date +%s
12 to 14 digits Milliseconds 1 (native unit) JavaScript Date.now(), Java System.currentTimeMillis()
15 to 17 digits Microseconds Divide by 1,000 PostgreSQL TIMESTAMP, Go UnixMicro(), Python logs
18 or more digits Nanoseconds Divide by 1,000,000 Kubernetes events, Prometheus, Go UnixNano()

Digit-length thresholds for seconds through nanoseconds

Modern systems emit epoch integers across four orders of magnitude. Entering 1700000000 (10 digits) resolves to November 14, 2023 as whole seconds, whereas 1700000000000 (13 digits) resolves to the exact same instant in milliseconds. Comparing a seconds vs milliseconds timestamp is straightforward because every millisecond value is 1,000 times larger.

If you paste a 13-digit millisecond value into a tool expecting seconds, the output jumps thousands of years into the future. Under the MDN JavaScript Date Object Reference, valid Date instances span +/- 8,640,000,000,000,000 milliseconds (8.64e15 ms) from the epoch, so out-of-range numbers trigger an invalid-date message instead of silent wrapping.

Handling negative pre-1970 timestamps and decimal fractions

Negative numbers such as -3600 represent instants prior to 1970-01-01T00:00:00Z. The digit counter strips any leading minus sign and trailing decimal fraction before choosing the unit, so -1700000000 still reads accurately as seconds.

Decimal timestamps like 1700000000.5 preserve sub-second milliseconds when multiplied into the Date constructor. When pulling raw numbers out of messy server traces, you can first extract timestamp numbers from raw log lines before pasting them here for conversion.

Converting Unix time to dates, ISO 8601 strings, and IANA time zones

You can type or paste human-readable strings into Timestamp or date to get both Unix seconds and Unix milliseconds back immediately. The tool supports unzoned dates, full zoned timestamps, and the literal keyword now.

Resolving unzoned ISO dates against your chosen time zone

Standard JavaScript Date.parse() treats 2026-04-19 as UTC midnight while treating 2026-04-19T14:30:00 as local time, which frequently causes off-by-one-day mistakes. To prevent that mismatch, this converter parses unzoned YYYY-MM-DD and YYYY-MM-DDTHH:mm:ss inputs using a two-step IANA convergence loop inside the active Time zone selection.

When an input already includes an explicit Z suffix or numeric offset like +05:30, the parser honors that exact instant as defined by IETF RFC 3339 Date and Time on the Internet. Changing the Time zone dropdown then updates the Converted display without altering the underlying UTC epoch.

Using the live clock, preset buttons, and date picker

The Now card at the top ticks every 1,000 milliseconds so you can grab the current Unix second with one click. Below the input box, three preset buttons let you jump straight to Now, In 24 hours (+86400 seconds), or Unix epoch (0).

For visual scheduling, Pick a date and time renders a native datetime-local control with one-second precision (step="1"). Any change in the picker writes the corresponding integer seconds back into Timestamp or date, making it straightforward to check recurring cron schedules alongside converted timestamps.

Why do daylight saving shifts and leap seconds cause bugs?

Unix time defines every day as exactly 86,400 seconds and ignores UTC leap seconds, while civil clocks shift forward or backward during daylight saving transitions. Mixing those two models without an IANA time zone database leads to duplicate hours, missing hours, and misaligned billing windows.

Tip: Always store and transmit timestamps as UTC integers or explicit RFC 3339 strings with offsets, and convert to an IANA zone like America/New_York or Europe/Berlin only at the final display layer.

POSIX 86,400-second days vs true UTC leap seconds

Because Unix timestamps assume 86,400 seconds per day, adding 86400 seconds always advances the UTC clock by 24 hours, even across a daylight saving boundary where local wall-clock time jumps by 23 or 25 hours. During a fall-back transition, an unzoned local time like 01:30 occurs twice, so explicit UTC offsets are essential for audit trails.

The Converted panel relies on the MDN Intl.DateTimeFormat API Reference to format Your time zone according to current and historical IANA rules. You can also inspect Relative time deltas calculated via Intl.RelativeTimeFormat across second, minute, hour, day, week, month, and year buckets.

Reading ISO week numbers and day-of-year counters

Analytics pipelines and log-rotation jobs often partition data by ordinal day or week number rather than calendar month. The Day of the year row counts from 1 to 365 (or 366 in leap years) in UTC, while ISO week outputs YYYY-Www anchored on the Thursday of each week.

Token-based authentication workflows share the same integer-second convention. When debugging expired sessions, you can inspect JWT expiration and issued-at claims (exp, iat, and nbf) and cross-check their exact UTC and local wall times here.

Debugging API logs, database indexes, and browser privacy

Checking production timestamps often involves sensitive customer records, session tokens, or internal deployment schedules. Running conversions directly inside your browser tab ensures none of those values cross the network, while keeping every converted format one click away.

  • Verifying microsecond and nanosecond logs: Paste 16-digit PostgreSQL timestamps or 19-digit Kubernetes event times directly to confirm human-readable UTC dates without counting zeros by hand.
  • Auditing database sort order: Compare two consecutive Unix milliseconds values to verify whether event rows or time-ordered IDs are monotonically increasing inside primary-key indexes.
  • Tracing clock skew across microservices: Switch Time zone between UTC and regional zones such as Asia/Tokyo or America/Chicago to spot servers logging local wall time without explicit offsets.
  • Comparing log captures: When troubleshooting race conditions between two deployments, you can compare two log snapshots side by side after normalizing their epoch timestamps to ISO 8601.

Questions

How does the converter tell seconds apart from milliseconds?

It checks the integer digit count before any decimal point. Inputs with 11 or fewer digits read as seconds, 12 to 14 digits read as milliseconds, 15 to 17 digits read as microseconds, and 18 or more digits read as nanoseconds.

Why do dates before 1970 produce negative Unix timestamps?

Unix time counts elapsed seconds forward and backward from January 1, 1970 at 00:00:00 UTC. Any instant earlier than that epoch is represented as a negative integer, such as -86400 for December 31, 1969.

What happens when pasting an ISO date without an offset?

When you enter an unzoned date such as 2026-04-19 or 2026-04-19T14:30:00, the tool resolves that wall-clock time inside your selected Time zone dropdown rather than assuming UTC.

What is the Year 2038 problem for 32-bit Unix timestamps?

Signed 32-bit integers overflow at 2,147,483,647 seconds, which corresponds to 03:14:07 UTC on January 19, 2038. Modern 64-bit systems and JavaScript Date objects avoid this cap, spanning roughly 285,616 years around 1970.

Why does JavaScript round nanosecond timestamps?

JavaScript stores Date values as 64-bit floating-point milliseconds, which have 53 bits of integer precision. Dividing an 18-digit or 19-digit nanosecond value by 1,000,000 maps it to the nearest millisecond for calendar display.

Does this timestamp converter send any dates or logs to a server?

No. Every calculation runs in your browser tab using standard JavaScript Date and Intl APIs, so internal log timestamps and schedules never leave your device.

Updated