What Is a Unix Timestamp (Epoch Time)?
Dev Nexus4 min read
A Unix timestamp is the number of seconds since 1970-01-01 UTC - a compact, timezone-neutral way to pin down a single moment in time.
If you have looked inside a log file, a JWT, a database row or an API response, you have seen a Unix timestamp: a plain number like 1752796800 sitting where you expected a date. It is one of the most common ways to store time in software, and once you understand what the number means, it stops looking cryptic.
This guide explains what a Unix timestamp is, where the count starts, what it measures, and why so many systems chose it over a written-out date. It is short on jargon and long on the intuition you actually need.
The Problem
Storing dates as text is surprisingly messy. Is 03/04/2026 the third of April or the fourth of March? Which timezone was it written in? Does it include daylight saving? Different locales, formats and offsets make written dates ambiguous and hard to compare or sort reliably.
Computers need something unambiguous: a single value that means the same instant everywhere on Earth, is trivial to compare (is A before B?), and takes almost no space to store. A formatted date string fails all three tests. That is the gap a Unix timestamp fills.
The Solution
A Unix timestamp answers those needs with one integer: the number of seconds elapsed since the Unix epoch, defined as 1970-01-01 00:00:00 UTC. Because it is measured from a fixed point in UTC, the same instant has the same number everywhere - no timezone confusion, no format ambiguity.
That design makes timestamps easy to sort (a bigger number is later), cheap to store (one integer), and safe to transmit across systems. It is why databases, filesystems, cookies, tokens and countless APIs all speak epoch time under the hood.
To turn one of these numbers into a date you can read, paste it into the Timestamp Converter - it runs in your browser and uploads nothing. And if you are generating test records that pair IDs with timestamps, the UUID Generator is a handy companion.
Step-by-Step Guide
- 1
Start at the epoch
The count begins at midnight UTC on undefined January undefined - the Unix epoch. At that exact instant the timestamp is
0. Every second since then adds one to the value, so the number only ever grows going forward in time. - 2
Count in seconds (usually)
The classic Unix timestamp counts whole seconds. Many modern platforms - JavaScript included - count milliseconds instead for finer resolution, which is why you will see both undefined-digit and undefined-digit values in the wild.
- 3
Read it as UTC
A timestamp is inherently a UTC instant. It carries no timezone of its own; you apply a timezone offset only when you want to display it as local wall-clock time. The number itself never changes with location.
- 4
Convert when you need a date
To make a timestamp human-readable, convert it:
1752796800becomes2026-07-18T00:00:00Z. A converter shows the local, UTC and ISO forms at once so you can pick the one your context needs.
Common Mistakes
Thinking a timestamp carries a timezone
It does not. A Unix timestamp is always a UTC instant. Any timezone you see is applied at display time. Treating the number itself as local time leads to off-by-hours bugs.
Confusing seconds with milliseconds
The original spec is seconds, but many APIs return milliseconds. A undefined-digit number is seconds; a undefined-digit number is milliseconds. Mixing them produces dates that are thousands of years off.
Assuming timestamps can't be negative
Dates before undefined are represented as negative timestamps. If you ever store historical dates, your code needs to handle values below zero rather than assuming time starts at the epoch.
Forgetting the 2038 limit on old systems
Systems that store epoch time in a signed undefined-bit integer overflow on undefined January undefined. Modern undefined-bit systems are fine, but legacy code and embedded devices may still be vulnerable.
Frequently Asked Questions
What is a Unix timestamp in simple terms?
It is the number of seconds that have passed since midnight UTC on 1 January 1970. That starting point is called the Unix epoch, and the timestamp is simply how many seconds have ticked by since then.
Why does Unix time start in 1970?
1970 was chosen as a convenient recent reference point when Unix was being developed in the early 1970s. It has been the standard epoch ever since, so the whole ecosystem counts from that date.
Is a Unix timestamp in UTC?
Yes. A Unix timestamp represents a single instant measured from a UTC starting point and carries no timezone itself. You apply a timezone only when displaying it as local time.
What does a Unix timestamp look like?
It is just an integer, such as 1752796800 for a value in seconds or 1752796800000 in milliseconds. There are no separators, letters or timezone markers - only digits.
How do I read a Unix timestamp as a date?
Convert it with a tool or code. Pasting it into the Timestamp Converter shows the local, UTC and ISO 8601 date at once, all computed in your browser without uploading the value.
Try the Tool
Timestamp Converter
Turn any epoch number into a readable date in your browser - nothing uploaded.
Related Tools
Related Articles
How to Convert a Unix Timestamp to a Date
A practical walkthrough for turning a raw Unix timestamp into a readable local, UTC or ISO date - and converting a date back into a timestamp.
Read articleSeconds vs Milliseconds Timestamps Explained
The difference between a 10-digit seconds timestamp and a 13-digit milliseconds one is a factor of 1000 - and getting it wrong sends your dates thousands of years off.
Read articleAre UUIDs Really Unique?
In practice UUIDs never collide - here is the math behind why, and the one thing people get wrong: a UUID is an identifier, not a secret.
Read article