Unix Timestamp Converter

Unix Timestamp Converter

Growing AI Skill PRO

Enter Calculation

Results

UTC Time
Feb 8, 2025 15:41:04 UTC
Timezone DateTime
America/New_York Feb 8, 2025 10:41:04 EST
America/Los_Angeles Feb 8, 2025 07:41:04 PST
Europe/London Feb 8, 2025 15:41:04 GMT
Europe/Paris Feb 8, 2025 16:41:04 CET
Asia/Tokyo Feb 9, 2025 00:41:04 JST
Australia/Sydney Feb 9, 2025 02:41:04 AEST
Asia/Dubai Feb 8, 2025 19:41:04 GST
Asia/Shanghai Feb 8, 2025 23:41:04 CST

Formula

DateUTC=1970-01-01 00:00:00 UTC+Unix Timestamp (s)seconds\text{Date}_{\text{UTC}} = \text{1970-01-01 00:00:00 UTC} + \text{Unix Timestamp (s)}\ \text{seconds}
Usage stats

Advertisement

Report an error on this page

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.

Timeline showing the Unix epoch starting point and seconds counting forward to a later date
A Unix timestamp counts the seconds elapsed since the epoch at 00:00:00 UTC on 1 January 1970.

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.

Advertisement

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.

World map with clock dials over four cities showing different local times for the same instant
The same timestamp maps to different local clock times across UTC, New York, London, Tokyo, and Sydney.

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.

Advertisement

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. The T separates the date from the time. A trailing Z ("Zulu") means the time is given in UTC, i.e. offset +00:00; otherwise an explicit offset such as +09:00 is 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's System.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 example America/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.

Last updated:

Most popular in Time and Date

View all Time and Date calculators