Unix timestamps represent the number of seconds elapsed since January 1, 1970 00:00:00 UTC.
Epoch Time to Date Converter & Calculator
Easily convert epoch time to date, or convert a timestamp to epoch with our free epoch calculator. Supports seconds, milliseconds, microseconds, and nanoseconds.
How to Convert Date to Epoch
If you are wondering how to convert epoch time to date or date to epoch, simply use this tool to calculate local or UTC date to multiple Unix timestamp precisions.
Related Time Tools
How Unix Epoch Time Works
Premise: Computer systems require a universal, timezone-agnostic method to store and calculate time without dealing with complex geographical calendar rules.
Evidence: Unix time solves this by representing a specific moment as a single scalar integer: the absolute number of seconds (or milliseconds) that have elapsed since the Unix Epoch (January 1, 1970, at 00:00:00 UTC). Because it is a simple integer, programming languages can instantly perform date arithmetic (like adding 86400 seconds to advance exactly one day).
Conclusion: Our converter instantly translates this machine-readable integer back into a human-readable UTC and Local ISO 8601 date, making it a critical tool for developers debugging database timestamps or system logs.
Unix Timestamp Conversion Examples
Here are some common epoch timestamp conversions spanning different units:
- Epoch Seconds to Date: 0 → 1970-01-01 00:00:00 UTC
- Epoch Milliseconds to Date: 0 → 1970-01-01 00:00:00 UTC
- Date to Unix Timestamp (Secs): 2026-01-01 00:00:00 UTC → 1767225600
- Date to Unix Timestamp (Ms): 2026-01-01 00:00:00 UTC → 1767225600000
10-Digit vs 13-Digit Unix Timestamps
A common point of confusion for developers is dealing with timestamp length. Unix time can be tracked in multiple resolutions:
- 10 Digits (Seconds): The traditional format. Example:
1781331129. Commonly used in Linux/Unix systems, MySQL, PHP, and Python. - 13 Digits (Milliseconds): Higher precision. Example:
1781331129000. Standard in JavaScript, Java, and most JSON REST APIs. - 16 Digits (Microseconds): Very high precision. Often used in high-frequency trading and databases like PostgreSQL.
- 19 Digits (Nanoseconds): Ultra precision. Supported by Go and Rust.
Paste your timestamp into the UtilNode Epoch Converter, and it will automatically detect the precision and convert it accurately.
Where Unix Timestamps Are Used
Epoch time is a fundamental concept in software engineering. You will frequently encounter Unix timestamps in:
- APIs & JSON payloads: Transmitting standardized dates across different systems.
- Databases: Storing exact moments efficiently (e.g., PostgreSQL, MySQL, MongoDB).
- JWTs (JSON Web Tokens): The
exp(expiration) andiat(issued at) claims are always formatted as Unix timestamps in seconds. - Application Logs: Timestamping server events for performance monitoring.
Frequently Asked Questions
What is the current Unix timestamp?
The current Unix timestamp is the exact number of seconds that have elapsed since the Unix Epoch (January 1, 1970, at 00:00:00 UTC). Our tool provides a live, continuously updating count at the top of the page.
How do I convert a Unix timestamp to a date?
Simply paste your 10-digit (seconds) or 13-digit (milliseconds) integer into the Epoch to Date field above. The tool automatically detects the precision and translates it into a human-readable ISO 8601 format, local time, and UTC.
Is Unix time the same as UTC?
While related, they are not exactly the same. Unix time represents a raw, numerical count of seconds since January 1, 1970 UTC. However, standard Unix time famously ignores leap seconds, meaning it does not perfectly map to true physical UTC without complex external adjustments.
What is the Year 2038 problem (Y2K38)?
Many legacy systems store the Unix timestamp as a signed 32-bit integer. The maximum value for this data type is 2,147,483,647. On January 19, 2038, at 03:14:07 UTC, the Unix time will hit this maximum limit. One second later, systems that haven't been upgraded to 64-bit integers will overflow and misinterpret the date as December 13, 1901, potentially causing widespread software failures.
Programming Syntax: How to get the current timestamp
Here is how you can fetch the current Unix timestamp across popular programming languages:
- JavaScript:
Math.floor(Date.now() / 1000) - Python:
import time; int(time.time()) - PHP:
time() - Java:
System.currentTimeMillis() / 1000L - Go:
time.Now().Unix() - Ruby:
Time.now.to_i
What is the difference between seconds and milliseconds in Unix time?
The format depends on the system or programming language being used:
- Seconds (10 digits): Commonly used by Unix shell commands, Python, PHP, and most database
TIMESTAMPcolumns. - Milliseconds (13 digits): Commonly used by JavaScript, Java, and many REST APIs.
If you pass a millisecond value to a system expecting seconds, your date will appear incorrectly (often in the year 1970 or far in the future), and vice versa.
Why does my converted date look wrong?
This is often due to one of three common issues:
- Unit Mismatch: Confusing seconds with milliseconds or microseconds.
- Time Zone Confusion: Unix timestamps are natively UTC. If your converter is set to "Local Time," it may be applying an offset that makes the date seem "off" compared to a UTC reference.
- Pre-1970 Dates: Dates before January 1, 1970, are represented by negative numbers, which some older systems or databases do not support.