How do I convert epoch seconds to a date?

Paste your epoch seconds value (e.g. 1764581115, 1163558854, or 1718320456) into the converter above. The tool automatically detects whether the value is in seconds (10 digits) or milliseconds (13 digits) and instantly displays the corresponding date in UTC, your local timezone, ISO 8601 format, and as relative time.

What is the epoch date for 1764581115?

The epoch timestamp 1764581115 converts to Monday, December 1, 2025 at 09:25:15 UTC. You can paste any epoch seconds value into the converter above to see its date instantly.

What is the Unix timestamp for January 1, 2024?

January 1, 2024 at 00:00:00 UTC has the Unix timestamp 1704067200 (in seconds) or 1704067200000 (in milliseconds). Use the 'Date to Timestamp' tab in the converter above to look up any date.

What is the difference between seconds and milliseconds timestamps?

Unix timestamps in seconds are 10 digits (e.g., 1704067200), while milliseconds timestamps are 13 digits (e.g., 1704067200000). Milliseconds provide more precision. JavaScript uses milliseconds, while many server-side languages use seconds.

What is the Unix Epoch?

The Unix Epoch is January 1, 1970 at 00:00:00 UTC. It's the reference point from which Unix timestamps are calculated. Dates before this time have negative timestamps.

How do I get the current Unix timestamp?

The current Unix timestamp is displayed at the top of this tool and updates in real-time. In JavaScript, use Date.now() for milliseconds or Math.floor(Date.now() / 1000) for seconds.

Why do programmers use Unix timestamps?

Unix timestamps are timezone-independent, easy to store (single number), simple to compare and sort, and can be easily converted to any timezone. They avoid timezone confusion when storing dates in databases or transferring between systems.

Epoch Converter

Convert epoch to date • unix timestamp to UTC • seconds to date

Free epoch converter online — paste any epoch value to instantly convert epoch to date. This tool converts unix timestamp to UTC, shows local time, ISO 8601, and relative formats. Convert seconds to date or convert any date back to a Unix epoch timestamp. Supports both seconds and milliseconds. 100% client-side — your data never leaves your browser.

Current Unix Timestamp

Seconds —

Milliseconds —

Enter Unix Timestamp:

Enter a timestamp in seconds (10 digits) or milliseconds (13 digits). Negative values for dates before 1970.

Example Timestamps

Select Date and Time:

Date

Time

Timezone

Unix Timestamp

Seconds

—

Milliseconds

—

Code Snippets

// JavaScript
const timestamp = 0;
const date = new Date(timestamp * 1000);
console.log(date.toISOString());

Quick Reference

Common Timestamps

`0`	Jan 1, 1970 (Epoch)
`86400`	1 day in seconds
`604800`	1 week in seconds
`2592000`	30 days in seconds
`31536000`	1 year in seconds

Format Detection

10 digits	Seconds (Unix standard)
13 digits	Milliseconds (JavaScript)
Negative	Before Jan 1, 1970
Max 32-bit	2147483647 (Y2K38)

Popular Epoch Timestamps to Date

Looking up a specific epoch value? Here are commonly searched epoch timestamps and their dates. Click any timestamp to convert it above.

Epoch Seconds	Date (UTC)	Description
`1764581115`	Mon, Dec 1, 2025 09:25:15	Commonly searched
`1764244800`	Thu, Nov 27, 2025 12:00:00	Commonly searched
`1718320456`	Thu, Jun 13, 2024 23:14:16	Commonly searched
`1163558854`	Wed, Nov 15, 2006 02:47:34	Commonly searched
`1704067200`	Mon, Jan 1, 2024 00:00:00	Start of 2024
`1735689600`	Wed, Jan 1, 2025 00:00:00	Start of 2025
`1767225600`	Thu, Jan 1, 2026 00:00:00	Start of 2026
`1000000000`	Sun, Sep 9, 2001 01:46:40	1 Billion seconds
`1500000000`	Fri, Jul 14, 2017 02:40:00	1.5 Billion seconds
`2000000000`	Wed, May 18, 2033 03:33:20	2 Billion seconds
`2147483647`	Tue, Jan 19, 2038 03:14:07	Y2K38 max 32-bit
`0`	Thu, Jan 1, 1970 00:00:00	Unix Epoch

Common Dates & Their Unix Timestamps

Looking up the Unix timestamp for a specific date? Here are commonly searched dates and their epoch values.

Date (UTC)	Unix Timestamp	Description
January 1, 2020 00:00:00	`1577836800`	Start of 2020
January 1, 2021 00:00:00	`1609459200`	Start of 2021
January 1, 2022 00:00:00	`1640995200`	Start of 2022
January 1, 2023 00:00:00	`1672531200`	Start of 2023
January 1, 2024 00:00:00	`1704067200`	Start of 2024
January 1, 2025 00:00:00	`1735689600`	Start of 2025
January 1, 2026 00:00:00	`1767225600`	Start of 2026
December 31, 1969 23:59:59	`-1`	Pre-epoch
February 29, 2024 00:00:00	`1709164800`	Leap day 2024
January 19, 2038 03:14:07	`2147483647`	Y2K38 overflow
January 1, 2030 00:00:00	`1893456000`	Start of 2030

Understanding Unix Timestamps

What is a Unix Timestamp?

A Unix timestamp (also known as Epoch time, POSIX time, or Unix Epoch time) is the number of seconds that have elapsed since January 1, 1970 at 00:00:00 UTC. This reference point is called the Unix Epoch.

For example, the timestamp 1704067200 represents January 1, 2024 at 00:00:00 UTC. Unix timestamps are timezone-independent, making them ideal for storing dates in databases and APIs.

Converting Unix Timestamp to UTC

A unix timestamp is inherently a UTC value. It counts seconds from January 1, 1970 00:00:00 UTC, so converting a unix timestamp to UTC means calculating the date and time that many seconds after the epoch.

For example, 1704067200 is exactly 1,704,067,200 seconds after midnight UTC on January 1, 1970 — which gives you January 1, 2024 00:00:00 UTC. This epoch converter does the math instantly and also shows the equivalent in your local timezone.

In code, converting seconds to date is straightforward:

JavaScript: new Date(1704067200 * 1000).toUTCString()
Python: datetime.utcfromtimestamp(1704067200)
PHP: gmdate('Y-m-d H:i:s', 1704067200)

Seconds vs Milliseconds

Unix timestamps can be expressed in two common formats:

Seconds (10 digits): The traditional Unix format. Used by most server-side languages like PHP, Python, and Ruby. Example: 1704067200
Milliseconds (13 digits): Provides more precision. Used by JavaScript's Date.now() and Java. Example: 1704067200000

This converter auto-detects which format you're using based on the number of digits.

The Year 2038 Problem (Y2K38)

Systems using 32-bit signed integers to store Unix timestamps will overflow on January 19, 2038 at 03:14:07 UTC. At this moment, the timestamp reaches 2,147,483,647 (the maximum 32-bit signed integer), and incrementing it causes overflow.

Modern systems use 64-bit integers, extending the range to approximately 292 billion years in either direction. More than enough for any practical application.

Why Use Unix Timestamps?

Timezone independence: A single number represents the same moment everywhere in the world.
Easy comparison: Simply compare two numbers to determine which date is earlier or later.
Storage efficiency: A single integer uses less space than date strings.
No ambiguity: Avoids confusion from different date formats (MM/DD vs DD/MM).
Easy arithmetic: Add or subtract seconds to calculate future or past dates.

Getting Current Timestamp in Code

Here's how to get the current Unix timestamp in various programming languages:

JavaScript: Math.floor(Date.now() / 1000) (seconds) or Date.now() (milliseconds)
Python: import time; int(time.time())
PHP: time()
Java: System.currentTimeMillis() / 1000
Go: time.Now().Unix()
Ruby: Time.now.to_i

Unix Timestamp FAQ

What is a Unix timestamp?

A Unix timestamp (also called Epoch time) is the number of seconds that have elapsed since January 1, 1970 at 00:00:00 UTC. It's a universal way to represent time as a single number, making it easy to store, compare, and transfer dates between systems.

How do I convert a Unix timestamp to a date?

Enter your timestamp in the converter above and click Convert. The tool automatically detects if it's in seconds or milliseconds and displays the date in multiple formats including UTC, local time, ISO 8601, and relative time.

How do I convert a unix timestamp to UTC?

Paste your unix timestamp into the converter above and the UTC date is shown instantly. Unix timestamps are always measured from January 1, 1970 00:00:00 UTC, so every unix timestamp directly maps to a UTC date and time. The converter also shows your local timezone for comparison.

How do I convert seconds to a date?

Enter the number of seconds (epoch seconds) into the converter to see the corresponding date. For example, 1704067200 seconds since the Unix Epoch equals January 1, 2024 00:00:00 UTC. The tool auto-detects seconds (10 digits) vs milliseconds (13 digits) and shows results in UTC, local time, ISO 8601, and relative format.

What's the difference between seconds and milliseconds?

Seconds timestamps are 10 digits (e.g., 1704067200), while milliseconds are 13 digits (e.g., 1704067200000). JavaScript uses milliseconds, while most server languages use seconds. This tool handles both automatically.

Can I convert dates before 1970?

Yes! Dates before the Unix Epoch (January 1, 1970) are represented as negative timestamps. For example, -86400 represents December 31, 1969. This converter fully supports negative values.

What is the Year 2038 problem?

The Y2K38 problem affects systems using 32-bit signed integers for timestamps. On January 19, 2038 at 03:14:07 UTC, the timestamp 2,147,483,647 overflows. Modern 64-bit systems are not affected.

How do I look up what date an epoch seconds value represents?

Paste your epoch seconds value (e.g. 1764581115, 1163558854, or 1718320456) into the input field above. The tool instantly shows the corresponding epoch date in multiple formats including UTC, local time, and ISO 8601. You can also append ?ts=1764581115 to the URL to share or bookmark a specific conversion.

What is the Unix timestamp for a specific date like January 1, 2024?

Switch to the Date to Timestamp tab, select your date and time, and the tool shows both the seconds and milliseconds Unix epoch timestamp. For reference, January 1, 2024 00:00:00 UTC is epoch 1704067200. See the lookup tables below for more common dates.

Is my data safe with this tool?

Absolutely. This converter runs 100% in your browser using JavaScript. No data is sent to any server. All conversions happen locally on your device.

What is ISO 8601 format?

ISO 8601 is an international standard for date/time representation: YYYY-MM-DDTHH:mm:ss.sssZ. The 'T' separates date and time, and 'Z' indicates UTC. Example: 2024-01-01T00:00:00.000Z.

Why do developers use Unix timestamps?

Unix timestamps are timezone-independent, easy to compare (just compare numbers), efficient to store, and avoid date format ambiguity. They're the standard for APIs, databases, and log files.