Unix Timestamp Converter

By Asira Tools Team · Last updated 20 November 2026

Convert a Unix timestamp to a readable UTC date, or a date back to seconds and milliseconds since the Unix epoch.

Advertisement

Unix Timestamp Converter

Thu, 01 Jan 2026 00:00:00 GMT
UTC dateThu, 01 Jan 2026 00:00:00 GMT
ISO 86012026-01-01T00:00:00.000Z
Seconds1767225600
Milliseconds1767225600000

Dates are shown in UTC so results are the same everywhere in the world. A seconds timestamp has 10 digits; a milliseconds timestamp has 13.

The Unix epoch:

Timestamp = seconds since 1 January 1970, 00:00:00 UTC  |  1 day = 86,400 seconds  |  Milliseconds = seconds × 1,000

What Is a Unix Timestamp?

A Unix timestamp is the number of seconds that have passed since midnight on 1 January 1970, Coordinated Universal Time. That moment is called the Unix epoch, and it is the starting point from which Unix systems, and most of modern computing, measure time. The timestamp 0 means the epoch itself. The timestamp 1767225600 means 1 January 2026 at midnight UTC, exactly 20,454 days later. Every second that passes adds one to the count, so the current timestamp is a ten-digit number that grows by about 31.5 million each year.

Timestamps are popular because they are simple numbers. A date written as "01/02/2026" is ambiguous: it means 1 February in most of the world and January 2 in the United States. A timestamp has no such ambiguity, no time zone, and no daylight saving complications. Sorting timestamps sorts events in time order. Subtracting two timestamps gives the elapsed seconds exactly. Storing them takes a single integer column. That is why APIs, databases, log files, and file systems store times as timestamps internally and only convert them to readable dates for display.

How to Use This Converter

To turn a timestamp into a date, choose "Timestamp to date", enter the number, and pick the unit: seconds or milliseconds. The result shows the UTC date, the ISO 8601 form, and the value in both seconds and milliseconds, so you can copy whichever form you need. To go the other way, choose "Date to timestamp" and enter a date in ISO format, such as 2026-01-01T00:00:00Z, and the tool returns the matching timestamp in both units.

All dates are shown in UTC, which keeps the results identical no matter where in the world you open this page. If you need the date in your local time zone, add your offset to the UTC result: for example, 1 January 2026 at 00:00 UTC is 1 January at 05:00 in Pakistan Standard Time, which is UTC plus 5 hours, and 31 December 2025 at 19:00 in New York, which is UTC minus 5 hours in winter.

Seconds Versus Milliseconds

The most common timestamp mistake is mixing up seconds and milliseconds. Unix timestamps are traditionally in seconds, and current values have 10 digits. JavaScript, however, measures time in milliseconds, so its timestamps have 13 digits: the same moment that is 1767225600 in seconds is 1767225600000 in milliseconds. The two differ by a factor of exactly 1,000, and feeding one to a function that expects the other gives a wildly wrong date: treating 1767225600000 as seconds lands you in the year 57,986, and treating 1767225600 as milliseconds lands you three weeks after the epoch, on 21 January 1970.

The digit count is the quickest way to tell them apart. A 10-digit timestamp is seconds; a 13-digit timestamp is milliseconds. If you see a 16-digit value, it is microseconds, used by some databases and tracing systems, and a 19-digit value is nanoseconds. When a date looks wrong by a huge margin, check the unit first: it is the cause of the problem more often than any other single mistake. This tool accepts both units and always shows both, so you can confirm which one you have.

The Year 2038 Problem

Unix time has a known limit. On systems that store the timestamp in a signed 32-bit integer, the largest possible value is 2,147,483,647, which is reached on 19 January 2038 at 03:14:07 UTC. One second later, the number overflows and wraps around to a large negative value, which those systems read as 13 December 1901. This is the Year 2038 problem, the 32-bit cousin of the Year 2000 bug. Modern 64-bit systems store timestamps in 64-bit integers, which pushes the overflow billions of years into the future, but embedded devices, old file formats, and legacy databases still use 32-bit time, and they will need fixing before 2038.

The same limit shows up in smaller ways today. A 32-bit timestamp cannot represent dates before 13 December 1901 or after 19 January 2038, so birth dates and far-future expiry dates sometimes break in old systems. If you are building something new, store timestamps as 64-bit integers and the problem disappears. JavaScript numbers are 64-bit floating point, so this tool handles dates far beyond 2038 without any trouble.

Where Timestamps Are Used

Timestamps are everywhere in software. Web APIs return them in JSON responses: a created_at field of 1767225600 tells a client exactly when a record was made, in a form every language can parse. JSON Web Tokens, the standard for API authentication, carry expiry times as timestamps, so a server can check whether a token is still valid with a single number comparison. Databases store created and updated times as timestamps or as datetime types that convert to them. Log files stamp each line with a timestamp so that events from different servers can be merged into one timeline.

File systems use timestamps too: every file has a modification time stored as seconds since the epoch, which is what you see when a file manager shows a date. Version control, build tools, and caches all compare timestamps to decide what changed and what needs rebuilding. When you see a ten-digit number in a URL, a cookie, or a database dump, there is a good chance it is a Unix timestamp, and pasting it into this converter will tell you the date in seconds.

Worked Example

Take the timestamp 1767225600. Dividing by 86,400, the number of seconds in a day, gives exactly 20,454, which tells you it falls exactly on a midnight, 20,454 days after the epoch. Counting forward from 1 January 1970 by 20,454 days lands on 1 January 2026, and because the division had no remainder, the time is exactly 00:00:00 UTC. The ISO form is 2026-01-01T00:00:00.000Z, and the milliseconds form is 1767225600000.

A famous milestone on the same scale is the timestamp 1000000000, one billion seconds after the epoch, which fell on Sunday 9 September 2001 at 01:46:40 UTC. Programmers celebrated it at the time, and it remains a handy reference point: any timestamp near one billion is from around 2001, and any timestamp near two billion is from around 2033. The next round milestone, two billion seconds, arrives on 18 May 2033 at 03:33:20 UTC.

Tips and Common Mistakes

Count the digits before converting. Ten digits means seconds, thirteen means milliseconds. If your result lands in 1970 or in the year 50000, you have the wrong unit. Divide or multiply by 1,000 and try again.

Remember that Unix time ignores leap seconds. Every day is treated as exactly 86,400 seconds, and the occasional leap second added to UTC to keep it aligned with the Earth's rotation is not counted as an extra second in Unix time. For almost all purposes this does not matter, but it means Unix time and UTC drift apart by the total number of leap seconds, currently 27, and that converting a timestamp to a date near a leap second can be off by a second.

Always include the Z in ISO dates. The letter Z at the end of an ISO date means UTC. Without it, a date such as 2026-01-01T00:00:00 may be read as local time, and the resulting timestamp will be off by your time zone offset. When converting a date to a timestamp, write the Z, or include an explicit offset such as +05:00.

Do not store dates as formatted strings. A string such as "Jan 1, 2026" cannot be sorted, subtracted, or compared reliably. Store the timestamp, and format it into a readable date only when you display it. Your future self, debugging a report at midnight, will be grateful.

Advertisement

Frequently Asked Questions

What is the Unix epoch?

The Unix epoch is midnight on 1 January 1970, 00:00:00 UTC. A Unix timestamp counts the seconds since that moment, so 0 is the epoch itself and 1767225600 is 1 January 2026 at midnight UTC.

How do I tell seconds and milliseconds apart?

Count the digits: a seconds timestamp currently has 10 digits and a milliseconds timestamp has 13, because milliseconds are seconds times 1,000. If your date lands in 1970 or the year 50000, you have the wrong unit.

What is the Year 2038 problem?

Systems storing timestamps in signed 32-bit integers overflow at 2,147,483,647 seconds, which is 19 January 2038 at 03:14:07 UTC, and wrap to 1901. Modern 64-bit systems are unaffected, but old embedded devices and file formats still need fixing.

Why are the results shown in UTC?

UTC has no time zones or daylight saving changes, so the same timestamp always converts to the same UTC date everywhere in the world. Add your local offset to convert: UTC+5 for Pakistan, UTC-5 for New York in winter.

What timestamp is 1 January 2026?

1767225600 seconds, or 1767225600000 milliseconds, since the epoch. That is exactly 20,454 days after 1 January 1970, which is why it falls exactly on midnight UTC.