Unix Timestamp Explained

A Unix timestamp is the number of seconds that have passed since the Unix epoch — midnight UTC on 1 January 1970. It’s the lingua franca of system time: databases, logs, APIs, and cron jobs all speak it. But reading 1726617600 as a date takes a tool, not mental math. Open the Timestamp Converter and it reads it for you, in either direction.

TL;DR

A Unix timestamp is a single integer that names a moment in time, independent of any timezone.

• Seconds since 1970-01-01 UTC — the epoch. One number, one instant, no AM/PM or DST to argue about.
• Convert both ways — turn a timestamp into a human date, or a date into a timestamp, right in your browser.
• No upload — the conversion runs locally, so your timestamp values never leave the device.

What a Unix timestamp is

The Unix epoch is 1970-01-01 00:00:00 UTC. A Unix timestamp is simply how many seconds have elapsed since that instant. The value 0 is the epoch itself; 1700000000 is a point in mid-November 2023. Every second that passes, the number grows by one.

Systems rely on it because it solves three problems at once:

• Unambiguous. 07/09/26 means July 9 in the US and September 7 in much of Europe. A timestamp has exactly one meaning everywhere.
• Timezone-free. It names an instant on the global clock. Anyone, anywhere, applies their own offset to read a wall-clock time from it.
• Sortable and comparable. Bigger numbers are later moments, so sorting is just numeric order — no date parsing required.

That last property is why logs, cache keys, and database created_at columns so often store an integer rather than a formatted string.

Seconds, milliseconds, and beyond

The classic Unix timestamp counts seconds. The Unix date +%s command gives you seconds. But JavaScript — and therefore every browser, Node service, and Date.now() call — counts milliseconds. The same moment looks different in each:

• Seconds: 1700000000
• Milliseconds: 1700000000000 (three extra digits)

Mix them up and you get a date in 1970 or the year 50,000. The Timestamp Converter handles both, and more. Its unit selector covers Auto, Seconds, Milliseconds, Microseconds, and Nanoseconds. In Auto mode it infers the unit from the digit count — 10 digits reads as seconds, 13 as milliseconds, 16 as microseconds, 19 as nanoseconds — so you rarely have to choose. When you do pick a unit explicitly, that choice wins.

Step-by-step: convert a timestamp

1. Pick the direction. Under Conversion mode, choose Timestamp to Date (number → human date) or Date to Timestamp (human date → number).
2. Enter the value. For Timestamp to Date, type the numeric timestamp. For Date to Timestamp, use the Date and time field to pick the moment.
3. Choose the unit. In the Timestamp unit list pick Auto, Seconds, Milliseconds, Microseconds, or Nanoseconds. Auto is fine unless you’re being deliberate.
4. Pick a time zone. The Time zone list offers nine common zones (see the next section) so the human-readable result reflects the wall-clock time you expect.
5. Press Convert. The Converted time panel shows Unix seconds, Unix milliseconds, ISO UTC, RFC 2822, UTC, Local, your selected zone, and relative offsets — one click on Copy all grabs everything.

Need the current instant? The live strip at the top ticks every second with the current seconds, milliseconds, and ISO value, and the Now action drops that value into the input.

Timezones and the nine-zone list

A timestamp has no timezone of its own — it’s an instant on the global clock. The timezone only matters when you render it as a wall-clock date. The converter offers a fixed list of nine zones: UTC, Local, America/New_York, Europe/London, Europe/Berlin, Asia/Tokyo, Asia/Seoul, Asia/Singapore, and Australia/Sydney. Together those cover the major regions most developers actually schedule across.

This is not a free-text IANA zone picker. If your city isn’t on the list, choose Local — which uses your browser’s own zone — or UTC, and convert mentally from there. The selected zone controls the “Selected zone” row of the result; UTC and Local rows are always shown regardless, so you always have an unambiguous reference point.

Limits and honesty

A few constraints worth knowing before you depend on the output:

• Nine fixed zones, no free input. You can’t type America/Sao_Paulo or Asia/Kolkata. Use Local or UTC and apply the offset yourself.
• Date range is capped. Values beyond 8,640,000,000,000,000 milliseconds — roughly the year 275760 — are outside the browser’s safe range and return an “unsafe range” error. That’s a JavaScript Date ceiling, not an arbitrary tool limit.
• Relative offsets are approximate. The relative figures are derived from the instant and are meant as a quick sanity check, not a precise countdown for a launch.

FAQ

Is a Unix timestamp in seconds or milliseconds?

It depends where it came from. The classic Unix timestamp is seconds (date +%s). JavaScript’s Date.now() returns milliseconds. The difference is three trailing zeros. If you paste a value and get a date in 1970 or thousands of years in the future, you’ve mismatched the unit — switch the Timestamp unit selector, or let Auto detect it by digit count.

What timezone is a Unix timestamp in?

UTC, effectively. A timestamp names a single instant on the global clock, so it has no local offset baked in. When you read it as a human date, the timezone you apply is what produces the wall-clock time. The converter always shows the UTC row so you have one unambiguous reference, plus Local and your selected zone.

Can I convert to my local timezone?

Yes, if it’s one of the nine listed zones. Choose Local to use your browser’s current timezone, or pick a specific zone from the list. If your zone isn’t among the nine options, there’s no free-text entry — use Local or UTC and apply your offset from there.

What is epoch?

The epoch is the fixed reference point 1970-01-01 00:00:00 UTC. A Unix timestamp is the count of seconds (or milliseconds, microseconds, nanoseconds) from that instant. The epoch itself is timestamp 0, and negative timestamps count backward to dates before 1970.