Unix / Epoch Timestamp Converter
Convert Unix timestamps to dates and dates to Unix time instantly. Supports seconds, milliseconds, microseconds, nanoseconds, UTC, local time, and time zones.
Current Unix Time
The current Unix timestamp is the number of seconds that have passed since January 1, 1970 at 00:00:00 UTC. Use this live timestamp when you need the current time for APIs, databases, logs, analytics tools, or development workflows.
Time Converter
Most Common Conversions
Unix time is traditionally measured in seconds, but many systems also use milliseconds: Seconds for Unix systems, APIs, and databases; milliseconds for JavaScript, logs, and analytics tools; microseconds for databases and event streams; nanoseconds for high-precision systems.
| Format | Value |
|---|
Timezone Conversion
Compare the same moment in UTC, your local timezone, and common business timezones. Changing the selector updates the display without changing the underlying timestamp.
| Timezone | Date and time |
|---|
Code examples
The first line for each programming language shows how to get the current epoch time. The second line shows how to convert an epoch timestamp to a human-readable date. Replace the example epoch time with your own value.
Seconds vs Milliseconds
A 10-digit timestamp is usually seconds. A 13-digit timestamp is usually milliseconds. Some databases and event streams use 16-digit microseconds or 19-digit nanoseconds. This converter auto-detects the unit and lets you override it when a value is ambiguous.
| Format | Example | Common use |
|---|---|---|
| Seconds | 1716239022 | Unix systems, APIs, databases |
| Milliseconds | 1716239022000 | JavaScript, logs, analytics tools |
| Microseconds | 1716239022000000 | Databases, event streams |
| Nanoseconds | 1716239022000000000 | High-precision systems |
Frequently Asked Questions
A Unix timestamp is a number that represents a specific moment in time. It counts how many seconds have passed since January 1, 1970 at 00:00:00 UTC, which is known as the Unix epoch. You can use a Unix timestamp converter to turn this number into a readable date and time, or convert a normal date back into Unix time.
Epoch time is another name for Unix time. It measures time as the number of seconds that have passed since the Unix epoch: January 1, 1970 at 00:00:00 UTC. The terms epoch time, Unix time, and Unix timestamp are often used interchangeably. An epoch converter helps translate these numbers into human-readable dates.
Unix time is traditionally measured in seconds. However, many modern systems also use milliseconds. A 10-digit timestamp is usually Unix time in seconds, such as 1716239022. A 13-digit timestamp is usually epoch time in milliseconds, such as 1716239022000. This matters because entering milliseconds as seconds can produce a date far in the future. A good Unix timestamp converter should detect seconds and milliseconds automatically.
To convert a Unix timestamp to a date, paste the timestamp into the converter. The tool should show the readable date in UTC, your local time, and any selected timezone. This is useful when reading logs, API responses, database records, analytics events, or developer output.
To convert a date to a Unix timestamp, enter the date and time into the converter, then choose the correct timezone. The tool will return the timestamp in seconds, milliseconds, microseconds, and nanoseconds. This is useful when scheduling API events, storing dates in databases, comparing times in code, or creating test data for development.
A Unix timestamp is based on UTC. It represents one exact moment in time, not a timezone-specific date. The same Unix timestamp can be displayed differently depending on the timezone. For example, the UTC time, New York time, London time, and Tokyo time may all show different clock times for the same timestamp. This is why a timestamp converter should show UTC, local time, and selected timezone results.
The most common reason is a timezone mismatch. Unix timestamps are based on UTC, but your browser, database, spreadsheet, or application may display the result in local time. To fix this, compare the UTC result with the local time result and confirm which timezone your system expects.
This usually happens when milliseconds are treated as seconds. For example, 1716239022 is a normal 10-digit Unix timestamp in seconds, while 1716239022000 is a 13-digit timestamp in milliseconds. If a system reads a 13-digit millisecond timestamp as seconds, the date may appear thousands of years in the future. Use the seconds vs milliseconds detection or manually switch the timestamp unit.
A date in 1970 usually means the timestamp value is very small, empty, rounded incorrectly, or being divided too many times. Timestamp 0 equals January 1, 1970 at 00:00:00 UTC. This issue can also happen if milliseconds are accidentally divided by 1,000 more than once, or if a missing timestamp defaults to zero.
JavaScript Date values are commonly based on milliseconds since the Unix epoch. That is why JavaScript timestamps are usually 13 digits instead of 10 digits. Date.now() returns epoch milliseconds. If you need Unix seconds in JavaScript, divide the millisecond value by 1,000 and round or floor the result.
A Unix timestamp usually means seconds since January 1, 1970 UTC. Epoch milliseconds count the same moment in time, but in milliseconds instead of seconds. For example, 1716239022 is Unix seconds, while 1716239022000 is epoch milliseconds. JavaScript, analytics tools, and many APIs often use epoch milliseconds. Databases, backend systems, and Unix-based systems often use Unix seconds.
The current Unix timestamp is the number of seconds that have passed since January 1, 1970 at 00:00:00 UTC up to the current moment. A current Unix timestamp tool should show the live timestamp in seconds, milliseconds, UTC date, and local date, with copy buttons for quick use.
Two timestamp converters may show different results if they use different default timezones, different formatting, or different assumptions about seconds versus milliseconds. To compare results correctly, make sure both tools are using the same timestamp unit and timezone. UTC is usually the safest reference point.
Yes. Negative Unix timestamps represent dates before January 1, 1970 at 00:00:00 UTC. Historical dates before the Unix epoch may appear as negative timestamp values. Not every system supports negative timestamps the same way, so older dates may require extra testing.
For APIs and databases, the best timestamp format depends on the system. Common formats include Unix seconds for backend systems and databases, epoch milliseconds for JavaScript and analytics tools, ISO 8601 for readable API responses, and UTC dates for consistent storage and comparison. When in doubt, store time in UTC and convert it to local time only when displaying it to users.