Unix Timestamps Explained: A Plain-English Guide
If you've ever seen a raw number like 1755600000 somewhere it should say a date — in a URL, a log file, an API response — you've run into a Unix timestamp. It looks meaningless at a glance, but it's actually one of the more elegant ideas in computing, and understanding what it represents makes those numbers a lot less mysterious.
What the number actually means
A Unix timestamp is the number of seconds that have passed since midnight UTC on January 1st, 1970 — a moment computing calls "the Unix epoch." That specific starting point isn't meaningful in itself; it was simply a convenient, round reference moment chosen when Unix-based systems needed a standard way to represent time internally. Every date after that point can be represented as a single, ever-increasing number of elapsed seconds, and every date before it as a negative number.
Why computers prefer this over a normal calendar date
Storing a date as year, month, day, hour, minute, and second — six separate fields — is how humans naturally think about time, but it's clumsy for a computer to work with directly. Comparing two dates, calculating the difference between them, or sorting a list of dates all become genuinely simple operations once time is just one number: subtracting two timestamps gives you an elapsed duration directly, and sorting a list of timestamps is just sorting a list of numbers. That efficiency is why timestamps show up constantly under the hood in databases, APIs, log files, and file systems, even though almost nobody wants to actually read a raw timestamp directly.
Seconds versus milliseconds — the detail that trips people up
One genuinely common source of confusion: some systems store Unix time in seconds (the original definition), while others — notably JavaScript's built-in Date.now() — use milliseconds instead, which is the same underlying concept multiplied by 1,000 for finer precision. Mixing these up produces a wildly wrong date, often landing somewhere in the very distant future or treating a small number as an almost-1970 date, because a millisecond timestamp interpreted as seconds is 1,000 times larger than it should be. If a converted date looks obviously wrong — decades off in either direction — checking whether you're mixing up seconds and milliseconds is usually the first thing worth trying.
Our Unix Timestamp Converter handles both units directly, with an explicit toggle, specifically because this mix-up is common enough to design around rather than assume away.
Related date math that comes up alongside timestamps
Working with raw timestamps often means working with other numeric date representations too. If you need to know which numbered day of the year a given date falls on — sometimes loosely called a Julian date in casual usage, though that term technically refers to something slightly different in astronomy — the Day of Year Calculator handles that conversion. And if a system references dates by ISO week number rather than a specific calendar date, the ISO Week Number Calculator and its reverse, the Week Number to Date Converter, cover that less common but still standardized format.
None of these representations are more "correct" than a normal calendar date — they're just different tools suited to different jobs, mostly on the machine side of things rather than the human-reading side. Knowing what they represent, and being able to convert between them when you actually need to read one, is really all there is to it.