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
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 |
|---|---|---|---|
| Unix | Jan 1, 1970 00:00:00 UTC | Seconds | Linux, macOS, POSIX, most web APIs |
| Windows FILETIME | Jan 1, 1601 00:00:00 UTC | 100-nanosecond intervals | Windows NT, NTFS, Active Directory |
| Cocoa / Mac | Jan 1, 2001 00:00:00 UTC | Seconds | macOS, iOS, Swift, Objective-C |
| GPS | Jan 6, 1980 00:00:00 UTC | Seconds | GPS satellites, navigation systems |
| NTP | Jan 1, 1900 00:00:00 UTC | Seconds | Network Time Protocol, legacy systems |
| Julian Date | Jan 1, 4713 BC 12:00 UTC | Days | Astronomy, 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:
- 1Input: 1717718400 seconds, format = seconds
- 2Convert to milliseconds: 1717718400 × 1000 = 1717718400000 ms
- 3new Date(1717718400000) = June 7, 2024 00:00:00 UTC
- 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:
- 1Input Unix timestamp in ms: 1717718400000
- 2Windows epoch offset from Unix: Jan 1, 1601 to Jan 1, 1970 = 11644473600 seconds = 11644473600000 ms
- 3Milliseconds since Windows epoch: 1717718400000 + 11644473600000 = 13362192000000 ms
- 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:
- 1GPS epoch: January 6, 1980 00:00:00 UTC = Unix ms 315964800000
- 2Target Unix ms: 1717718400000
- 3Difference: 1717718400000 − 315964800000 = 1401753600000 ms
- 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
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.
Formula Source: Standard Mathematical References
by Various