Epoch Converter

Convert timestamps between different epoch systems used in various operating systems, protocols, and applications.

Interpreted Date

Sat, 18 Jul 2026 06:36:15 GMT

ISO 8601: 2026-07-18T06:36:15.190Z

Local: 18/7/2026, 12:06:15 pm

Epoch Conversions

Unix Epoch

January 1, 1970 00:00:00 UTC

Seconds: 1784356575

Milliseconds: 1784356575190

Days: 20652.275176

Windows FILETIME

January 1, 1601 00:00:00 UTC

Seconds: 13428830175

Milliseconds: 13428830175190

Days: 155426.275176

FILETIME: 134288301751900000

Cocoa/Mac

January 1, 2001 00:00:00 UTC

Seconds: 806049375

Milliseconds: 806049375190

Days: 9329.275176

GPS Epoch

January 6, 1980 00:00:00 UTC

Seconds: 1468391775

Milliseconds: 1468391775190

Days: 16995.275176

NTP Epoch

January 1, 1900 00:00:00 UTC

Seconds: 3993345375

Milliseconds: 3993345375190

Days: 46219.275176

Julian Date Epoch

January 1, 4713 BC 12:00:00 UTC (Julian)

Seconds: 212651116575

Milliseconds: 212651116575190

Days: 2461239.775176

About Epochs

Different systems use different reference points (epochs) for counting time. Unix uses January 1, 1970, while Windows uses January 1, 1601. GPS time started on January 6, 1980, and NTP uses January 1, 1900 as its epoch.

What Is an Epoch Converter?

An epoch converter translates a numeric timestamp into a human-readable date and time — and vice versa — across multiple epoch systems used by different operating systems, programming languages, and network protocols. An epoch is simply a fixed reference point in time from which timestamps are counted, usually in seconds, milliseconds, or smaller units.

Different computing platforms chose different epochs for practical and historical reasons. Unix systems count seconds from January 1, 1970; Windows uses January 1, 1601 (the start of a Gregorian 400-year cycle); GPS satellites count from January 6, 1980; and NTP network time uses January 1, 1900. Converting between these systems is a frequent task for developers, system administrators, and data engineers.

This epoch converter supports six major epoch systems — Unix, Windows FILETIME, Apple Cocoa, GPS, NTP, and Julian Date — and accepts input in seconds, milliseconds, microseconds, or nanoseconds. The result includes both the human-readable date and the equivalent numeric values across all supported epoch systems.

Epoch Conversion Formula

All epoch conversions share the same underlying mathematics: subtract (or add) the difference between two epochs' reference points to translate a timestamp from one system to another.

Epoch Conversion

timestampB = timestampA_ms - epochA_ms + epochB_ms

Where:

  • timestampA_ms= The input timestamp converted to milliseconds (ms)
  • epochA_ms= The reference epoch of the input system in Unix milliseconds
  • epochB_ms= The reference epoch of the target system in Unix milliseconds
  • timestampB= The equivalent timestamp in the target epoch system

Major Epoch Systems

Each computing domain selected an epoch that made sense for its era and purpose:

System Epoch Reference Unit Used By
UnixJan 1, 1970 00:00:00 UTCSecondsLinux, macOS, POSIX, most web APIs
Windows FILETIMEJan 1, 1601 00:00:00 UTC100-nanosecond intervalsWindows NT, NTFS, Active Directory
Cocoa / MacJan 1, 2001 00:00:00 UTCSecondsmacOS, iOS, Swift, Objective-C
GPSJan 6, 1980 00:00:00 UTCSecondsGPS satellites, navigation systems
NTPJan 1, 1900 00:00:00 UTCSecondsNetwork Time Protocol, legacy systems
Julian DateJan 1, 4713 BC 12:00 UTCDaysAstronomy, historical chronology

Understanding Timestamp Formats

Timestamps can be expressed at different resolutions depending on the application's precision needs:

  • Seconds: The classic Unix timestamp format. Example: 1717718400 = June 7, 2024 00:00:00 UTC. Used in most web APIs and log files.
  • Milliseconds: Standard in JavaScript (Date.now() returns milliseconds). Multiply the seconds value by 1,000. Example: 1717718400000.
  • Microseconds: Multiply the seconds value by 1,000,000. Used in high-resolution system clocks and databases like PostgreSQL.
  • Nanoseconds: Multiply the seconds value by 1,000,000,000. Used in Go's time package and precision hardware timestamping.

This converter accepts all four formats and normalizes them to milliseconds internally before performing epoch comparisons.

Real-World Applications

Epoch conversion is a daily task in software engineering and data analysis. When debugging API responses, developers often encounter Unix timestamps that need to be converted to readable dates. Log analysis tools display events in epoch time, and converting them is essential for correlating incidents across systems.

Database engineers working with Windows systems frequently encounter FILETIME values stored in NTFS metadata, Active Directory attributes, and Exchange email headers. Converting these to Unix time or ISO dates is necessary for cross-platform data pipelines.

GPS and telecommunications engineers deal with GPS epoch time when processing satellite data, navigation fixes, and GNSS (Global Navigation Satellite System) signals. GPS time does not include leap seconds, which creates an additional offset from UTC that grows over time.

Worked Examples

Convert Unix Seconds to Date

Problem:

What date does the Unix timestamp 1717718400 represent?

Solution Steps:

  1. 1Input: 1717718400 seconds, format = seconds
  2. 2Convert to milliseconds: 1717718400 × 1000 = 1717718400000 ms
  3. 3new Date(1717718400000) = June 7, 2024 00:00:00 UTC
  4. 4ISO 8601: 2024-06-07T00:00:00.000Z

Result:

Unix timestamp 1717718400 = Friday, June 7, 2024 at 00:00:00 UTC.

Convert to Windows FILETIME

Problem:

What is the Windows FILETIME for June 7, 2024?

Solution Steps:

  1. 1Input Unix timestamp in ms: 1717718400000
  2. 2Windows epoch offset from Unix: Jan 1, 1601 to Jan 1, 1970 = 11644473600 seconds = 11644473600000 ms
  3. 3Milliseconds since Windows epoch: 1717718400000 + 11644473600000 = 13362192000000 ms
  4. 4Convert to 100-nanosecond intervals: 13362192000000 × 10000 = 133621920000000000

Result:

Windows FILETIME for June 7, 2024 = 133621920000000000 (100-nanosecond intervals since Jan 1, 1601).

Convert GPS Time

Problem:

How many GPS seconds correspond to June 7, 2024?

Solution Steps:

  1. 1GPS epoch: January 6, 1980 00:00:00 UTC = Unix ms 315964800000
  2. 2Target Unix ms: 1717718400000
  3. 3Difference: 1717718400000 − 315964800000 = 1401753600000 ms
  4. 4Convert to seconds: 1401753600000 / 1000 = 1401753600 GPS seconds

Result:

June 7, 2024 = 1,401,753,600 seconds since the GPS epoch (January 6, 1980).

Tips & Best Practices

  • JavaScript's Date.now() returns milliseconds — remember to select 'Milliseconds' as the format when pasting from browser console.
  • Unix timestamps in API responses are usually in seconds (10 digits); JavaScript timestamps are in milliseconds (13 digits).
  • GPS time is currently 18 seconds ahead of UTC due to accumulated leap seconds — account for this in navigation applications.
  • The 'Set Current Time' button lets you convert today's exact moment to all epoch systems simultaneously.
  • Windows FILETIME values appear as very large integers (18+ digits) — if you see one in a hex editor, this converter will decode it.
  • NTP timestamps will overflow in 2036 on legacy implementations; modern NTP uses era numbers to extend the range.

Frequently Asked Questions

A Unix timestamp is the number of seconds that have elapsed since January 1, 1970 at 00:00:00 UTC, not counting leap seconds. It is the most widely used timestamp format in computing and is the default in most programming languages, web APIs, and database systems. JavaScript's Date.now() returns milliseconds, so divide by 1000 to get a Unix timestamp in seconds.
Windows chose January 1, 1601 as its epoch because that date is the start of a 400-year Gregorian calendar cycle, which simplifies certain date arithmetic. The FILETIME format also uses 100-nanosecond intervals rather than seconds, giving it much higher precision than Unix time. This difference means Windows timestamps require conversion before they can be used with Unix-based tools.
No — GPS time does not include leap seconds, while UTC does. GPS time and UTC were synchronized at the GPS epoch (January 6, 1980), but since then UTC has added 18 leap seconds (as of 2024) while GPS has not. This means GPS time is currently 18 seconds ahead of UTC, and this offset must be accounted for in precise timing applications.
The Year 2038 problem (Y2K38) affects 32-bit Unix systems that store timestamps as signed 32-bit integers. The maximum value of a signed 32-bit integer represents January 19, 2038 at 03:14:07 UTC; after that, the counter overflows to a large negative number. Modern 64-bit systems are not affected, but legacy embedded systems remain vulnerable.
NTP (Network Time Protocol) counts seconds from January 1, 1900, whereas Unix time starts from January 1, 1970. The difference between the two epochs is exactly 2,208,988,800 seconds (70 years). NTP uses a 32-bit seconds field and a 32-bit fractional seconds field, giving it sub-nanosecond precision, but the 32-bit seconds counter will overflow in 2036.

Sources & References

Last updated: 2026-06-06

💡

Help us improve!

How would you rate the Epoch Converter?

<>

Editorial Note

MyCalcBuddy Editorial Team

This page is maintained as an educational calculator reference.

Source

Formula Source: Standard Mathematical References

by Various

UpdatedLast reviewed: May 2026
CheckedFormula checks are based on standard references and internal QA review.

Privacy choices

MyCalcBuddy uses necessary storage for the site to work. Optional analytics, notifications, and future advertising features stay off unless you allow them.