Unix timestamps are the backbone of how computers track time. A Unix timestamp counts the number of seconds that have passed since January 1, 1970, 00:00:00 UTC (the Unix epoch). If you work with APIs, databases, or log files, you will encounter Unix timestamps constantly.
Developers use Unix timestamp converters when debugging API responses. A backend might return a field like created_at: 1752892800 and you need to know that this corresponds to July 18, 2026 at 12:00pm UTC without doing mental arithmetic.
Database administrators convert timestamps when writing queries. PostgreSQL stores timestamps in various formats, and converting between Unix epoch values and human-readable dates is a routine task when analyzing time-series data or scheduling jobs.
Log analysis requires timestamp conversion. Server logs from nginx, Apache, or application frameworks often use Unix timestamps or ISO 8601 formats. Converting these to local time helps when correlating events across services deployed in different timezones.
A Unix timestamp is the number of seconds (or milliseconds) since the Unix epoch: midnight UTC on January 1, 1970. This single number represents a precise moment in time, independent of timezones or daylight saving. To convert a timestamp to a date, the tool adds that many seconds to the epoch date and formats the result.
Converting a date to a timestamp works in reverse: the tool calculates how many seconds exist between the epoch and the target date. This is straightforward but must account for leap seconds in some systems, though most Unix implementations ignore leap seconds and use a smoothed timescale.
The tool displays both seconds and milliseconds, since JavaScript uses milliseconds internally (Date.now() returns milliseconds). Unix systems and most APIs use seconds. The distinction matters: 1752892800 (seconds) is July 18, 2026, but 1752892800 (milliseconds) is January 21, 1970.
Input
1752892800 (seconds)
Output
2026-07-18T12:00:00.000Z (ISO 8601), July 18, 2026 12:00:00 UTC
This is a typical API response timestamp
Input
1752892800000 (milliseconds)
Output
2026-07-18T12:00:00.000Z (ISO 8601), July 18, 2026 12:00:00 UTC
JavaScript Date.now() format, same moment as above
Input
0 (seconds)
Output
1970-01-01T00:00:00.000Z, January 1, 1970 00:00:00 UTC
The Unix epoch
Input
2147483647 (seconds)
Output
2038-01-19T03:14:07.000Z, January 19, 2038 03:14:07 UTC
The Y2K38 limit for 32-bit signed integers
Input
July 4, 2026, 6:00pm UTC
Output
1751655600 (seconds), 1751655600000 (milliseconds)
Converting a human-readable date to timestamp
Pitfalls to avoid
What is a Unix timestamp?
A Unix timestamp is the number of seconds that have elapsed since January 1, 1970, 00:00:00 UTC, not counting leap seconds. It is also called Unix epoch time or POSIX time.
How do I know if a timestamp is in seconds or milliseconds?
Count the digits. Timestamps in seconds have 10 digits for dates between 2001 and 2286. Timestamps in milliseconds have 13 digits for the same range. If you see 1752892800, that is seconds. If you see 1752892800000, that is milliseconds.
Are Unix timestamps affected by timezones?
No. Unix timestamps represent a specific moment in UTC. They are timezone-independent. When you convert a timestamp to a human-readable date, the display format depends on your timezone, but the underlying moment is the same everywhere.
What is the Y2K38 problem?
Systems that store Unix timestamps as 32-bit signed integers can only represent values up to 2147483647, which corresponds to January 19, 2038 at 03:14:07 UTC. After this, the value overflows. Most modern systems use 64-bit integers and are not affected.
Why does JavaScript use milliseconds instead of seconds?
JavaScript's Date object was designed to provide higher precision for browser applications. The Date.now() method and Date constructor use milliseconds since the epoch. You convert to seconds by dividing by 1000 and rounding.
Can I convert timestamps before 1970?
Yes. Dates before the Unix epoch have negative timestamps. For example, December 31, 1969 23:59:59 UTC has a timestamp of -1. This tool handles negative timestamps correctly.
What is ISO 8601 format?
ISO 8601 is an international standard for representing dates and times. The format is YYYY-MM-DDTHH:MM:SS.sssZ, where T separates date and time, and Z indicates UTC. For example, 2026-07-18T12:00:00.000Z.
How accurate are Unix timestamps?
Unix timestamps are accurate to the second (or millisecond with JavaScript). They do not account for leap seconds, which are inserted approximately every 18 months. For most applications, this discrepancy is negligible.
Unix timestamps are based on UTC and do not account for leap seconds. The live timestamp updates every second using your device's system clock. For applications requiring leap second accuracy, consult a dedicated time service.