Epoch Time Converter

Convert a Unix timestamp to a readable date, or a date to epoch time. See UTC and your local time together, with support for seconds and milliseconds.

Current epoch time · seconds

—

Live clock uses your device time

Timestamp to date

Paste a timestamp and choose its unit.

Date to timestamp

Select a date, time and how to interpret it.

Conversions run in your browser. The live clock follows your device clock; it is not a server time check. Local dates use your device’s time zone rules.

Last Updated: 23-Sep-2026 5 min read

What is epoch time?

Epoch time, also called a Unix timestamp, is a number that represents a moment in time. For Unix time, counting starts at January 1, 1970, at 00:00:00 UTC. That starting point is called the Unix epoch.

Think of it as a counter: timestamp 0 is the starting moment, 60 is one minute later, and 86400 is one day later. Negative values represent moments before 1970.

Unix time conventionally counts seconds and does not count leap seconds separately. Some systems store the same moment in milliseconds instead. JavaScript dates, for example, use milliseconds. One second equals 1,000 milliseconds.

Developers use timestamps in APIs, databases, application logs and event records. A single number makes it easier to store and compare moments without relying on a country’s date format.

How to use the epoch time converter

Convert a Unix timestamp to a date

Paste the number into Unix timestamp.
Select Seconds or Milliseconds to match the source data.
Choose Convert to date.
Read the UTC date, local date and ISO 8601 result. Use a copy button to reuse the result.

For example, enter 1704067200 and select seconds. The result is January 1, 2024, at 00:00:00 UTC.

Convert a date to a Unix timestamp

Choose the date and enter a time, including seconds if needed.
Select whether the entered time is in UTC or your local time zone.
Choose Convert to timestamp to see seconds and milliseconds.

Use current time fills both converters with the same moment. The live counter continues running, while your conversion results stay fixed until you convert again.

Epoch time formula: seconds and milliseconds

Milliseconds = seconds × 1,000
Seconds = milliseconds ÷ 1,000

For example, 1704067200 × 1000 = 1704067200000. These two numbers describe the same instant, using different units. If the timestamp includes a partial second, the seconds result can contain a decimal: 1500 ms = 1.5 s.

To convert a date to epoch time, calculate the elapsed time from the Unix epoch to that date in UTC. Use a date library or this converter for calendar calculations, because month lengths, leap years and local daylight saving changes make manual calculations error-prone.

Unix timestamp examples

All dates in this table are UTC. Your local display may show a different time or calendar date.

Verified epoch values in seconds and milliseconds
UTC date and time	Seconds	Milliseconds
1969-12-31 23:59:59	`-1`	`-1000`
1970-01-01 00:00:00	`0`	`0`
1970-01-02 00:00:00	`86400`	`86400000`
2000-01-01 00:00:00	`946684800`	`946684800000`
2024-01-01 00:00:00	`1704067200`	`1704067200000`
2025-01-01 00:00:00	`1735689600`	`1735689600000`

UTC, local time and daylight saving time

A timestamp identifies an instant; a time zone controls how that instant appears on a clock. For example, 1704067200 is January 1, 2024, at 00:00 UTC and 05:30 in India Standard Time. The timestamp itself does not change.

When converting a date back to a timestamp, the input time zone matters. Midnight UTC and midnight in your local zone usually represent different moments. This converter defaults to UTC so that the interpretation is explicit.

In locations with daylight saving time, some local clock times occur twice when clocks move back. This tool uses the earlier occurrence. Times skipped when clocks move forward are rejected. Use UTC when you need to identify a particular instant without this ambiguity.

Unix timestamp code examples

JavaScript

// Current Unix time in whole seconds
Math.floor(Date.now() / 1000);
// Convert seconds to an ISO date in UTC
new Date(1704067200 * 1000).toISOString();
// "2024-01-01T00:00:00.000Z"
// Convert a UTC date to seconds
Date.parse("2024-01-01T00:00:00Z") / 1000;
// 1704067200

Python

from datetime import datetime, timezone
# Convert seconds to a timezone-aware UTC date
datetime.fromtimestamp(1704067200, tz=timezone.utc)
# Convert a UTC date to seconds
int(datetime(2024, 1, 1, tzinfo=timezone.utc).timestamp())
# 1704067200

The Z in an ISO date means UTC. Supplying an explicit time zone helps avoid unexpected results on computers in different locations.

Common timestamp conversion mistakes

Wrong unit: interpreting milliseconds as seconds can produce a date thousands of years away. Check the source’s unit instead of relying only on digit count.
Wrong time zone: a local date and its UTC equivalent can fall on different days.
Extra characters: paste only the number, without commas, quotes or labels.
Lost precision: this converter supports millisecond precision. Microsecond and nanosecond units are not supported; convert them to milliseconds first.
Incorrect device time: the live timestamp can be inaccurate if your device clock is wrong.

FAQ on Epoch Time Converter

Are epoch time and Unix time the same?

In this converter, both mean time measured from January 1, 1970, at 00:00:00 UTC. More generally, an epoch is a reference starting point, and other computing systems can use different epochs.

Is a Unix timestamp in seconds or milliseconds?

Unix timestamps conventionally use seconds, but many applications store milliseconds. Modern values are often 10 digits in seconds or 13 digits in milliseconds. Digit count is only a clue; confirm the unit with the source.

Does a Unix timestamp have a time zone?

A Unix timestamp represents an instant relative to the UTC epoch. It does not store a local time zone. The same timestamp can be displayed in UTC, India Standard Time or another zone.

Can epoch time be negative or zero?

Yes. Zero represents January 1, 1970, at 00:00:00 UTC. Negative timestamps represent earlier moments; for example, -1 second is December 31, 1969, at 23:59:59 UTC.

Does Unix time include leap seconds?

Unix time does not count leap seconds separately. It treats a normal calendar day as 86,400 seconds, so it is not a continuous count of every elapsed physical second across leap-second events.

What is the Year 2038 problem?

A signed 32-bit Unix seconds field reaches its maximum value, 2147483647, on January 19, 2038, at 03:14:07 UTC. Systems using that representation need a wider or otherwise suitable time format to represent later dates. This converter is not limited to signed 32-bit seconds.