Timestamp Converter

What is a Unix timestamp?#

A Unix timestamp counts the seconds that have passed since 1970-01-01 00:00:00 UTC — the so-called Unix epoch. It is the lingua franca of logs, databases, APIs, and file metadata because it is a single integer with no timezone, no locale, and no daylight-saving ambiguity. 1700000000 means the exact same instant in Tokyo, London, and Lima; a wall-clock string like “2023-11-14 14:13:20” cannot make that claim until you also say whose clock and what offset.

The catch is that two conventions coexist in the wild. Classic Unix time counts in seconds (10 digits today, like 1700000000). JavaScript’s Date, Java’s System.currentTimeMillis(), and most frontend code count in milliseconds (13 digits, like 1700000000000). Mix them up and your “5 minutes ago” becomes “5,000 minutes ago”. This page auto-detects which one you pasted and shows every common rendering of that instant side by side, so you can copy whichever shape your downstream system expects.

How to use it#

1. Type or paste a value into the Input box. You can paste a pure number (seconds or milliseconds — the tool decides which by magnitude) or a human date string such as 2026-07-26T12:00:00Z. The placeholder shows both shapes.
2. Use the three buttons under the input as needed: now() fills the current instant as milliseconds, Sample loads a reference value, Clear empties the field.
3. Read the result panel. Each row is one canonical form of the same instant: ISO 8601 (the Z-suffixed UTC string APIs expect), Seconds (Unix time), Millis (JS-style), UTC (human-readable UTC), and Local (the instant rendered in your browser’s timezone).

Key features#

• Magnitude-based unit detection. Any numeric value below 10,000,000,000 is read as seconds; anything larger as milliseconds. That boundary sits around the year 2286 for seconds and 1970 for milliseconds, so every realistic present-day value is classified correctly without a radio button.
• Accepts both numbers and date strings. Paste 1700000000, 1700000000000, or an ISO/HTTP-style date — the parser handles all of them and reports a clear error if the string is not a real date.
• Five output forms at once. ISO 8601, Unix seconds, Unix milliseconds, UTC prose, and local prose — so you copy the exact representation your database, log line, or frontend needs without re-formatting by hand.
• 100% client-side. Nothing is sent anywhere; the conversion is just Date arithmetic in your browser.

Worked example#

Paste 1700000000 (a round, 10-digit value — clearly seconds). The panel resolves that single instant into:

ISO 8601:  2023-11-14T22:13:20.000Z
Seconds:   1700000000
Millis:    1700000000000
UTC:       November 14, 2023 at 10:13:20 PM UTC
Local:     (rendered in your own timezone)

Now paste 1700000000000 (three extra zeros — milliseconds). Because the value now exceeds the 1e10 threshold, it is read as milliseconds and resolves to the same instant — the panel is identical. That is the whole point of the magnitude rule: the same moment, expressed in either convention, decodes to one unambiguous answer.

FAQ#

How does the tool decide between seconds and milliseconds?#

By size. A 10-digit value like 1700000000 is below 10 billion, so it is treated as seconds; a 13-digit value like 1700000000000 is above that cutoff, so it is treated as milliseconds. The cutoff is safe because 10 billion seconds lands in the year 2286, while 10 billion milliseconds lands in early 1970 — no plausible timestamp falls in the ambiguous zone.

Why does my local time differ from someone else’s?#

The Local row renders the instant in whatever timezone your operating system is set to. The UTC row is absolute. Two people pasting the same timestamp will see the same UTC and ISO rows but different Local rows — which is correct, because the instant is the same and only the wall clock differs.

The timestamp I got from my backend has 13 digits — is it broken?#

No, it is just milliseconds. Many runtimes (JavaScript, Java, some Python libraries) default to millisecond precision. Drop it into the input as-is; the tool detects the magnitude and gives you the matching 10-digit seconds value in the Seconds row for any system that expects classic Unix time.