399
Timestamp → date
From seconds (or milliseconds) since 1970 to a readable UTC date and time.
CALCULATOR · TIME & DATE · UNIX TIME
Unix Timestamp Converter
Unix time is the world’s shared stopwatch: the number of seconds since 1970-01-01 00:00:00 UTC. Every log line, API response, and database row stamped 1790000000 means the same instant — Monday, September 21, 2026 14:13:20 UTC — no matter whose timezone you are in. This converter goes both ways: turn a timestamp into a readable date (13-digit values are auto-read as milliseconds), or turn a date and time back into seconds since the epoch, with ISO-8601 and the day of the week thrown in.
The 60-second rule
Unix time = seconds since 1970-01-01T00:00:00Z. To read a stamp, count forward from that instant; to make one, count the seconds from the epoch to your date. At the default, 1,790,000,000 seconds after the epoch lands on Monday, September 21, 2026 14:13:20 UTC (ISO-8601: 2026-09-21T14:13:20Z) — 20,717 full days in. Paste a 13-digit value instead and it is divided by 1,000 first: 1790000000000 becomes the same instant.
Output · formula · meaning
| Output | Formula | What it means |
|---|---|---|
| UTC date and time | epoch + stamp seconds | Monday, September 21, 2026 14:13:20 UTC at the default — the human-readable form of 1790000000. |
| ISO-8601 string | YYYY-MM-DDTHH:MM:SSZ | 2026-09-21T14:13:20Z — the unambiguous, sortable, API-friendly spelling of the same instant. |
| Unix timestamp (reverse) | Date.UTC(fields) ÷ 1000 | 1,789,999,980 for 2026-09-21 14:13 UTC — seconds since the epoch, ready for a log or an API. |
| Millisecond handling | if value ≥ 10¹²: value ÷ 1000 | 13-digit inputs are treated as milliseconds and divided by 1,000 before conversion. |
Who uses this
- The backend developer: a log line stamped 1790000000 becomes Monday, September 21, 2026 14:13:20 UTC — no more guessing which deploy caused the incident.
- The API integrator: checking that a webhook’s
createdfield really means the right minute before trusting it — and generating stamps to send back. - The data analyst: turning epoch columns in a CSV export into dates a human (and a pivot table) can read, without writing a throwaway script.
- The student: seeing that 0 = 1970-01-01 and negative numbers are rejected makes the whole idea of time-as-a-number click.
Accuracy & limitations
The math is exact, but Unix time has two quirks. Leap seconds are not counted: every UTC day is treated as exactly 86,400 seconds, so the stamp drifts from true solar time by the leap seconds added since 1972 (currently 27). UTC only: a stamp names one instant worldwide — your local timezone never enters the conversion. The 32-bit signed integer maxes out at 2,147,483,647 (2038-01-19 03:14:07 UTC, the Y2038 problem); this calculator uses full 64-bit math and caps input at 4,102,444,800 (year 2100).
400
Date → timestamp
From a calendar date and time (UTC) to seconds since the epoch.
The worked example, line by line
Defaults, timestamp → date: enter 1790000000. It is below 10¹², so it is read as seconds. Add 1,790,000,000 seconds to 1970-01-01T00:00:00Z and you land on Monday, September 21, 2026 14:13:20 UTC — ISO-8601 2026-09-21T14:13:20Z, day of week Monday, 20,717 full days after the epoch.
Millisecond branch: enter 1790000000000. It is ≥ 10¹², so it is divided by 1,000 → 1790000000 seconds → the same Monday, September 21, 2026 14:13:20 UTC.
Defaults, date → timestamp: 2026-09-21 14:13 UTC. Seconds from the epoch to that instant = 1,789,999,980 (twenty seconds shy of the first default, because no seconds field is offered). Feed 1789999980 into the top converter and you get Monday, September 21, 2026 14:13:00 UTC back — a clean round-trip.
Error branches: abc → “not a number”; -5 → negative rejected (Unix time starts at 0); 99999999999 → past the year-2100 cap of 4,102,444,800; February 30 in the date fields → “that date does not exist”.
Cite this calculatorBright Side Kit. “Unix Timestamp Converter.” brightoolbox.com, 2026.
Bright Side Kit. "Unix Timestamp Converter." https://brightoolbox.com/unix-time-converter/ Accessed October 23, 2026.Frequently asked questions
How do I tell if my timestamp is in seconds or milliseconds?
Count the digits. A 10-digit number like 1790000000 is seconds; a 13-digit number like 1790000000000 is milliseconds. The converter above applies that rule automatically: anything at or above 10¹² is divided by 1,000 first. When in doubt, convert it — if the date lands decades in the future, you were holding milliseconds.
Why does Unix time start in 1970?
Early Unix needed a simple, universal zero point, and 1970-01-01 00:00:00 UTC was close at hand when the convention was set. It was not a cosmic choice — just the engineering habit of counting seconds from a fixed instant, stored in a 32-bit integer, that the whole internet inherited.
What is the maximum Unix timestamp?
The 32-bit signed maximum is 2,147,483,647 — 2038-01-19 03:14:07 UTC, the Y2038 problem. This calculator does its math in 64-bit and accepts stamps up to 4,102,444,800 (2100-01-01 00:00:00 UTC), which covers every realistic use.
Does a Unix timestamp account for time zones?
No — and that is the point. A stamp names one instant in UTC, identical for everyone on Earth; time zones only enter when you display it. Both converters here work in UTC, so 1790000000 always means Monday, September 21, 2026 14:13:20 UTC.
Why is there no leap second in a Unix timestamp?
Unix time deliberately ignores leap seconds: every day is exactly 86,400 seconds, and a minute always has 60 of them. The result drifts slightly from true solar time (27 seconds as of 2026), but the arithmetic stays beautifully simple — which is why databases and APIs use it.
How do I convert a date to a Unix timestamp?
Count the seconds from 1970-01-01T00:00:00Z to your date — or just use the second panel above: enter year, month, day, hour, and minute (UTC) and it returns the stamp. 2026-09-21 14:13 UTC, for example, is 1,789,999,980.