What Is a Unix Timestamp?
A Unix timestamp is a single number that represents a specific moment in time. It counts the number of seconds that have elapsed since the Unix epoch — midnight (00:00:00) on 1 January 1970, in Coordinated Universal Time (UTC). Because it is just a plain integer, it is the same everywhere on the planet at any given instant, which makes it the global standard for storing and exchanging dates in software, databases, log files, and APIs.
This converter takes that raw number and turns it into a human-readable date and time, showing the result in UTC alongside major cities such as New York, London, Tokyo, and Sydney so you can see exactly what the same instant looks like around the world.
How to Use the Converter
- Enter your Unix timestamp into the input field (for example, 1700000000).
- Confirm whether your value is in seconds or milliseconds — most timestamps are in seconds, but JavaScript and some APIs use milliseconds (13 digits instead of 10).
- Read the converted date and time in UTC, then compare it across the listed time zones.
The Formula Explained
To turn a timestamp into a readable date, you add the number of seconds to the epoch:
Date = 1 January 1970 00:00:00 UTC + (timestamp seconds)
To convert any local time back into a timestamp, you measure the seconds between that moment and the epoch. Time zones do not change the timestamp itself — they only shift how the same instant is displayed. New York in winter is UTC−5, London is UTC+0, Tokyo is UTC+9, and Sydney is UTC+10 or +11 during daylight saving.
Worked Example
Take the timestamp 1700000000. Adding that many seconds to the epoch gives 14 November 2023, 22:13:20 UTC. The same instant is 17:13:20 in New York, 22:13:20 in London, and 07:13:20 the next morning in Tokyo.
Common Unix Timestamps Reference
A Unix timestamp counts the number of seconds elapsed since the Unix epoch, 00:00:00 UTC on 1 January 1970. The table below lists landmark values that are useful for sanity-checking your own data. Every date shown is in UTC — the same instant will display as a different wall-clock time in New York, London, Tokyo or Sydney.
| Unix timestamp | Digits | UTC date and time | ISO 8601 | Why it matters |
|---|---|---|---|---|
| 0 | 1 | 1 Jan 1970, 00:00:00 | 1970-01-01T00:00:00Z | The Unix epoch itself — the zero point of the count |
| 1000000000 | 10 | 9 Sep 2001, 01:46:40 | 2001-09-09T01:46:40Z | First billion-second mark; the "one gigasecond" milestone |
| 1234567890 | 10 | 13 Feb 2009, 23:31:30 | 2009-02-13T23:31:30Z | The famous ascending-digit timestamp, widely used as a test value |
| 1500000000 | 10 | 14 Jul 2017, 02:40:00 | 2017-07-14T02:40:00Z | Round marker often seen in sample data sets |
| 1700000000 | 10 | 14 Nov 2023, 22:13:20 | 2023-11-14T22:13:20Z | Recent round marker; handy for spotting stale data |
| 2000000000 | 10 | 18 May 2033, 03:33:20 | 2033-05-18T03:33:20Z | The two-billion-second mark, still inside 32-bit range |
| 2147483647 | 10 | 19 Jan 2038, 03:14:07 | 2038-01-19T03:14:07Z | Maximum value of a signed 32-bit integer — the Year 2038 rollover |
Use the digit count as a unit check. For any date between 2001 and 2286, a timestamp in seconds has 10 digits, while the same instant in milliseconds has 13 digits. So 1700000000 is 14 Nov 2023, but 1700000000000 (13 digits) is the same instant expressed in milliseconds — feed it in as seconds and you land in the year 55,844. If your converted date looks absurdly far in the future, divide by 1,000; if it lands in January 1970, you probably passed milliseconds where seconds were expected, or the value was truncated.
Negative values are legal and simply count backwards from the epoch: −86400 is 31 Dec 1969, 00:00:00 UTC. Some older systems and databases reject negatives, which is why pre-1970 birth dates sometimes break legacy software.
Time Unit and Offset Conversion Table
Seconds per time unit
Because Unix time is a plain count of seconds, arithmetic on timestamps is ordinary arithmetic. To move a timestamp forward by one day, add 86,400; to move back one week, subtract 604,800.
| Unit | Seconds | Conversion from seconds |
|---|---|---|
| 1 millisecond | 0.001 | seconds × 1,000 = milliseconds |
| 1 second | 1 | milliseconds ÷ 1,000 = seconds |
| 1 minute | 60 | seconds ÷ 60 |
| 1 hour | 3,600 | seconds ÷ 3,600 |
| 1 day | 86,400 | seconds ÷ 86,400 |
| 1 week | 604,800 | seconds ÷ 604,800 |
| 1 common year (365 days) | 31,536,000 | seconds ÷ 31,536,000 |
| 1 leap year (366 days) | 31,622,400 | seconds ÷ 31,622,400 |
The day figure follows directly from the definition: \(1\ \text{day} = 24 \times 60 \times 60 = 86{,}400\ \text{seconds}\). Note that Unix time treats every day as exactly 86,400 seconds, even a day that contains a leap second — see the glossary below.
Worked example: adding 30 days
Start from 1700000000 (14 Nov 2023, 22:13:20 UTC) and add 30 days:
$$1{,}700{,}000{,}000 + (30 \times 86{,}400) = 1{,}700{,}000{,}000 + 2{,}592{,}000 = 1{,}702{,}592{,}000$$
Converting 1702592000 gives 14 Dec 2023, 22:13:20 UTC — the same clock time 30 days later, because UTC has no daylight saving. In New York, however, both dates fall in Eastern Standard Time (UTC−5), so the local display is 17:13:20 on both days; had the span crossed a DST boundary, the local clock time would have shifted by an hour even though the arithmetic is identical.
UTC offsets for the displayed zones
Offsets below are the current civil-time rules for each zone as set by national law; they have changed historically and can change again.
| City | IANA identifier | Standard time | Daylight time |
|---|---|---|---|
| New York, USA | America/New_York | UTC−5 (EST) | UTC−4 (EDT) |
| London, UK | Europe/London | UTC+0 (GMT) | UTC+1 (BST) |
| Tokyo, Japan | Asia/Tokyo | UTC+9 (JST) | No DST observed |
| Sydney, Australia | Australia/Sydney | UTC+10 (AEST) | UTC+11 (AEDT) |
Sydney's daylight period runs during the southern-hemisphere summer, so it is offset from the northern-hemisphere DST periods of New York and London. Each country sets its own switch-over dates, and they do not coincide; this is why a fixed "New York is 5 hours behind London" rule fails for a few weeks each spring and autumn.
Offsets change the display, never the timestamp. A single Unix timestamp identifies one absolute instant. Rendering it in Tokyo rather than in UTC adds 9 hours to the displayed clock reading, but the underlying integer is unchanged. This is precisely why timestamps are the safe format for storing and transmitting times: convert to a local zone only at the moment you show the value to a person.
Key Terms Explained
- Unix epoch
- The reference instant from which Unix time is counted: 00:00:00 UTC on 1 January 1970. It is an arbitrary but universally agreed origin, chosen by the early Unix developers.
- Unix timestamp (epoch time, POSIX time)
- An integer giving the number of seconds elapsed since the Unix epoch, excluding leap seconds. Values before 1970 are negative. Because it is a single number with no zone attached, it is unambiguous worldwide.
- UTC vs GMT
- UTC (Coordinated Universal Time) is the modern atomic-based time standard used as the world's civil time reference. GMT (Greenwich Mean Time) is the older astronomical standard based on the mean solar time at the Greenwich meridian. In everyday use the two labels refer to the same clock reading, but they are defined differently, and in the UK "GMT" also names the country's winter standard time.
- UTC offset
- The fixed difference between a local clock and UTC, written as +HH:MM or −HH:MM — for example UTC+09:00 for Tokyo. Some zones use non-whole-hour offsets such as UTC+05:30 (India) or UTC+05:45 (Nepal).
- DST (daylight saving time)
- The seasonal practice of advancing local clocks, usually by one hour, so that evenings have more daylight. A zone that observes DST has two offsets in a year. Not all countries use it, and the switch dates differ between those that do.
- ISO 8601
-
The international standard for writing dates and times as text, for example
2023-11-14T22:13:20Z. TheTseparates the date from the time. A trailingZ("Zulu") means the time is given in UTC, i.e. offset +00:00; otherwise an explicit offset such as+09:00is appended. ISO 8601 strings sort correctly as plain text, which makes them convenient in logs and filenames. - Milliseconds vs seconds timestamps
-
Unix time is defined in seconds, but many environments — notably JavaScript's
Date.now()and Java'sSystem.currentTimeMillis()— return milliseconds. Confusing the two is the most common timestamp bug. Divide by 1,000 (discarding the remainder) to get seconds; multiply by 1,000 to go the other way. Microsecond (16-digit) and nanosecond (19-digit) timestamps also appear in databases and tracing systems. - Leap second
- An extra second occasionally inserted into UTC to keep it aligned with the Earth's slightly irregular rotation. Unix time deliberately ignores leap seconds: every day is treated as exactly 86,400 seconds. As a result, a Unix timestamp can repeat or be smoothed ("smeared") across a leap-second event, and the difference between two timestamps is not always the exact number of physical SI seconds between the two instants.
- IANA time zone identifier
-
A name from the IANA Time Zone Database (also called the tz or Olson database), written as
Area/Location— for exampleAmerica/New_York,Europe/London,Asia/Tokyo,Australia/Sydney. Each identifier carries the zone's full history of offset and DST rule changes, so it converts past dates correctly. Prefer these identifiers over ambiguous abbreviations: "CST" alone can mean US Central, China, or Cuba Standard Time. - 32-bit signed integer limit and the Year 2038 problem
- A signed 32-bit integer can hold values up to \(2^{31} - 1 = 2{,}147{,}483{,}647\). Systems that store Unix time in such a field can represent no instant later than 19 Jan 2038, 03:14:07 UTC; one second afterwards the value overflows and typically wraps to −2,147,483,648, which reads as 13 Dec 1901. Modern systems use 64-bit time values, which push the limit hundreds of billions of years into the future, but embedded devices, old file formats and legacy databases can still be affected. Long-dated records — mortgages, certificates, pension schedules — can hit the limit well before 2038.
- Negative timestamps
- Timestamps below zero represent instants before 1970. For example, −1 is 31 Dec 1969, 23:59:59 UTC. They are valid under the POSIX definition, but some libraries, databases and older 32-bit systems handle them poorly, which is why historical dates are often stored as date strings instead.
A practical rule follows from these definitions: store and transmit instants as Unix timestamps or ISO 8601 strings with an explicit offset, keep a zone identifier separately when the user's local context matters, and convert to local time only for display. This is general technical guidance; for systems with legal, financial or safety implications, follow the specific standards that apply to your domain and jurisdiction.
Frequently Asked Questions
Why does my timestamp look 1,000× too big? It is probably in milliseconds. Divide by 1,000 to get seconds.
Does the timestamp account for time zones? No. A Unix timestamp is always based on UTC. The displayed local times are just different views of one universal moment.
What is the year 2038 problem? Systems storing timestamps as 32-bit integers will overflow on 19 January 2038. Modern 64-bit systems avoid this entirely.