Unix Timestamp Converter: Epoch Time to Date and Back

Paste an epoch value to see the date it stands for in UTC and your local time, or enter a date to get its timestamp in seconds and milliseconds.

Runs in your browserFree, no sign-upLast reviewed October 8, 2026

Fill in the settings to see your result here.

Your result appears here instantly — nothing is uploaded.

Quick answers

What is a Unix timestamp?: It is a count of the seconds that have passed since midnight UTC on 1 January 1970, known as the Unix epoch. Because it is a single number with no time zone, the same value means the same instant everywhere. It is also called epoch time, Unix time or POSIX time.
How do I convert a Unix timestamp to a date?: Divide the seconds by 86,400 to get days since 1 January 1970, then count forward, or let a tool do it. In this converter, choose Timestamp → date, paste the number, and read the ISO 8601, UTC and Local lines.
Is my timestamp in seconds or milliseconds?: Count the digits. Current timestamps in seconds have 10 digits, such as 1700000000, and in milliseconds 13 digits, such as 1700000000000. Both of those are the same instant, and this page detects which one you entered.
What date is Unix timestamp 0?: Thursday 1 January 1970 at 00:00:00 UTC. That moment is the epoch. Negative timestamps count backwards from it, so -1 is 31 December 1969 at 23:59:59 UTC.
Does a Unix timestamp have a time zone?: No. It always counts from midnight UTC, so it identifies one instant worldwide. A time zone only comes in when the number is turned into a readable date, which is why this page shows a UTC line and a separate Local line for the same value.
What is the maximum 32-bit Unix timestamp?: 2147483647, which is 19 January 2038 at 03:14:07 UTC. One second later a signed 32-bit counter overflows. This is the year 2038 problem. This converter is not affected and handles later values normally.

Why use Unix Timestamp Converter

A Unix timestamp is the number of seconds since 00:00:00 UTC on 1 January 1970. Paste one in and this page shows the moment it represents as an ISO 8601 string, a UTC date and your own local time: 1700000000, for example, is 14 November 2023 at 22:13:20 UTC. Ten-digit values are read as seconds and thirteen-digit values as milliseconds, without you having to say which. Switch the direction to turn a date such as 2026-01-01T00:00:00Z into its timestamp, 1767225600. The Value field starts on the current time, so the page opens showing the Unix time right now.

Unix timestamp to date reference table

Each timestamp below was converted with this page. Times are UTC.

Unix timestamp (seconds)	Date and time (UTC)	Note
0	Thu, 1 Jan 1970 00:00:00	The Unix epoch
86400	Fri, 2 Jan 1970 00:00:00	Exactly one day later
946684800	Sat, 1 Jan 2000 00:00:00	Start of 2000
1000000000	Sun, 9 Sep 2001 01:46:40	First 10-digit timestamp
1234567890	Fri, 13 Feb 2009 23:31:30	Digits in sequence
1500000000	Fri, 14 Jul 2017 02:40:00
1600000000	Sun, 13 Sep 2020 12:26:40
1700000000	Tue, 14 Nov 2023 22:13:20
1735689600	Wed, 1 Jan 2025 00:00:00	Start of 2025
1767225600	Thu, 1 Jan 2026 00:00:00	Start of 2026
1798761600	Fri, 1 Jan 2027 00:00:00	Start of 2027
1800000000	Fri, 15 Jan 2027 08:00:00
1893456000	Tue, 1 Jan 2030 00:00:00	Start of 2030
2000000000	Wed, 18 May 2033 03:33:20
2147483647	Tue, 19 Jan 2038 03:14:07	Largest signed 32-bit value
4102444800	Fri, 1 Jan 2100 00:00:00	Start of 2100

Worked conversions in both directions

Seconds to a date

Direction Timestamp → date, Value 1700000000

ISO 8601 2023-11-14T22:13:20.000Z. UTC Tue, 14 Nov 2023 22:13:20 GMT. Milliseconds 1700000000000. Relative to epoch 19,675.93 days after 1970.

Milliseconds to a date

Direction Timestamp → date, Value 1700000000000

Seconds 1700000000. ISO 8601 2023-11-14T22:13:20.000Z.

Thirteen digits, so it is read as milliseconds and gives the same instant as the example above.

A date with a UTC marker to a timestamp

Direction Date → timestamp, Value 2026-01-01T00:00:00Z

Seconds 1767225600. Milliseconds 1767225600000. Relative to epoch 20,454.00 days after 1970.

A date with an offset

Direction Date → timestamp, Value 2026-10-08T12:00:00+05:30

Seconds 1791441000. ISO 8601 2026-10-08T06:30:00.000Z.

Noon at five and a half hours ahead of UTC is 06:30 UTC. The offset is applied before the count is taken.

A date before 1970

Direction Date → timestamp, Value 1969-07-20T20:17:00Z

Seconds -14182980. Relative to epoch 164.15 days before 1970.

Negative values are valid and mean a moment before the epoch.

A timestamp pasted with separators

Direction Timestamp → date, Value 1,700,000,000

Seconds 1700000000. ISO 8601 2023-11-14T22:13:20.000Z.

Commas, underscores and spaces are stripped before the number is read.

Seconds or milliseconds: how the unit is detected

Mixing up seconds and milliseconds is the most common mistake with epoch values. Unix system calls, shell tools, JWT exp and iat claims and most SQL functions use seconds. JavaScript's Date.now(), Java's System.currentTimeMillis() and many JSON APIs use milliseconds. Feed seconds to code that expects milliseconds and you get a date in January 1970. Do the opposite and you get a date tens of thousands of years away.

This page decides by size. A value of 100,000,000,000 or more, ignoring the sign, is read as milliseconds. Anything smaller is read as seconds. The cut-off works for every present-day value: a timestamp in seconds does not reach it until the year 5138, and a timestamp in milliseconds passed it on 3 March 1973.

Two limits follow from that rule. A millisecond timestamp for a moment before 3 March 1973 is short enough to be read as seconds, so convert those by removing the last three digits first. Microsecond and nanosecond timestamps, with 16 and 19 digits, are not recognised: a microsecond value is treated as milliseconds and lands in a far-future year, and a nanosecond value is rejected as out of range. Trim them to 13 or 10 digits before pasting. A decimal such as 1700000000.5 is accepted, and the fraction appears as milliseconds in the ISO 8601 line.

How to get the current Unix timestamp in code

Language	Current time in seconds
JavaScript	Math.floor(Date.now() / 1000)
Python	int(time.time())
PHP	time()
Java	System.currentTimeMillis() / 1000
C#	DateTimeOffset.UtcNow.ToUnixTimeSeconds()
Go	time.Now().Unix()
Ruby	Time.now.to_i
Bash	date +%s
MySQL	SELECT UNIX_TIMESTAMP()
PostgreSQL	SELECT EXTRACT(EPOCH FROM now())

Date.now() in JavaScript and System.currentTimeMillis() in Java return milliseconds, which is why they are divided by 1000 here. The PostgreSQL expression returns a value with a fractional part.

Seconds in common time spans

Add or subtract these to move a timestamp by a fixed amount.

Span	Seconds
1 minute	60
1 hour	3,600
1 day	86,400
1 week	604,800
30 days	2,592,000
365 days	31,536,000
366 days (leap year)	31,622,400

Months and years vary in length, so adding a fixed number of seconds does not always land on the same calendar date and time.

The year 2038 problem and leap seconds

Software that stores Unix time in a signed 32-bit integer can count no higher than 2,147,483,647, reached at 03:14:07 UTC on 19 January 2038. The next second wraps the counter round to a large negative number, which reads as a date in December 1901. Systems with a 64-bit time value are not affected, and neither is this page, which works in JavaScript's millisecond-based dates. The risk sits in older embedded devices, file formats and database columns that fixed a 32-bit field. Any program that calculates dates more than a few years ahead can hit it well before 2038.

Unix time also ignores leap seconds. Every day is treated as exactly 86,400 seconds long, even though 27 leap seconds have been added to UTC since 1972. So a Unix timestamp is not a true count of elapsed seconds since 1970, and the difference between two timestamps can be out by a second or more across a leap second. For logs, APIs and databases this almost never matters. For precise scientific timing it does.

Using Unix Timestamp Converter

1
Set Direction to Timestamp → date or Date → timestamp.
2
Enter the Value. For a timestamp, type the number in seconds or milliseconds. For a date, use ISO 8601 such as 2023-11-14T22:13:20Z, or YYYY-MM-DD.
3
Read the Converted panel: Seconds, Milliseconds, ISO 8601, UTC, Local and Relative to epoch.
4
Copy the All formats block to take every representation with you in one paste.

Answers to common questions

Why is the Local time different from the UTC time?

They are the same instant written two ways. The UTC and ISO 8601 lines are at zero offset. The Local line uses the time zone and date format your browser is set to, including daylight saving, so it changes from one device to another.

How is a date without a time or time zone interpreted?

A plain date such as 2026-10-08 is read as midnight at the start of that day in your browser's time zone, so the timestamp depends on where you are. To get midnight UTC, write 2026-10-08T00:00:00Z, which gives 1791417600 everywhere.

What date formats can I enter?

ISO 8601 is the reliable choice: 2023-11-14, 2023-11-14T22:13:20Z, or with an offset such as 2023-11-14T22:13:20+01:00. Other formats are passed to the browser's own date parser and may or may not be understood. Text that cannot be read as a date gives an error.

What does Relative to epoch mean?

It is the distance from 1 January 1970 in days, to two decimal places: the timestamp in seconds divided by 86,400. For 1700000000 it reads 19,675.93 days after 1970. For a negative timestamp it reads days before 1970.

What does the Z at the end of the ISO 8601 time mean?

Z stands for zero offset, meaning the time is given in UTC. The ISO 8601 line on this page always ends in Z. A time written with +05:30 or -08:00 instead is the same kind of string with a local offset.

How do I convert a JWT exp or iat value?

Those claims are Unix timestamps in seconds. Paste the number with Direction set to Timestamp → date. If the result is earlier than the current time, the token has expired. Compare using the UTC line to rule out a time zone mix-up.

Why did my timestamp turn into a date in 1970?

A date in January 1970 usually means a seconds value was treated as milliseconds somewhere in your code, making it a thousand times too small. A date of exactly 1 January 1970 usually means the value was 0, empty or null.

Is epoch time the same as Unix time?

In everyday use, yes. An epoch is any fixed starting point for counting time, and the Unix epoch is 1 January 1970 UTC. Other systems use other epochs, for example Excel counts days from 1900, so check which one a value uses before converting it.