Unix Time Converter

Unix time turns a moment into a single number. Instead of storing “November 14, 2023 at 22:13:20 UTC” as words and calendar fields, a Unix timestamp stores the number of seconds associated with that instant since the Unix epoch, 1970-01-01 00:00:00 UTC. The Unix Time Converter changes seconds into a readable UTC date and also changes UTC date text back into Unix seconds. It is built for software logs, API payloads, database rows, cache expirations, message queues, cron output, and debugging sessions where a numeric timestamp needs a human translation.

UTC is central to the page. A timestamp represents a global instant, not a wall clock in one city. Local displays can change by time zone, daylight saving time, and computer settings, so the primary result is always shown in UTC. For nearby unit conversions, use the time converter. For storage fields that often appear beside timestamps, use the digital storage converter. If a timestamp is attached to weather or sensor data, the temperature converter can help standardize the other values in the record.

What the Unix epoch means

The epoch is the zero point for the scale. Unix timestamp 0 is 1970-01-01 00:00:00 UTC. Timestamp 1 is one second later. Timestamp 86400 is one ordinary 24-hour day later, displayed as 1970-01-02 00:00:00 UTC. Negative timestamps point before the epoch, although older systems and some databases may not support every negative value.

This converter uses seconds for the main timestamp input because that is the classic Unix convention. JavaScript dates internally use milliseconds since the same epoch, so the result panel also shows milliseconds. That second-versus- millisecond distinction is one of the most common timestamp errors in programming.

Formula

For timestamp-to-date mode, the idea is:

$\text{UTC instant} = \text{1970-01-01 00:00:00 UTC} + \text{Unix seconds}$

The JavaScript date operation behind the calculator multiplies seconds by 1000 to obtain milliseconds:

$\text{milliseconds since epoch} = \text{Unix seconds} \times 1000$

For date-to-timestamp mode, parsed UTC milliseconds are divided by 1000 and truncated to whole seconds:

$\text{Unix seconds} = \operatorname{trunc}\left(\frac{\text{milliseconds since epoch}}{1000}\right)$

Truncation means fractional seconds in the text input are not rounded up by this calculator. A parsed value at 22:13:20.900 UTC returns the same whole-second timestamp as 22:13:20.000 UTC.

Example calculation

With the default mode Timestamp to UTC and timestamp 1700000000, the calculator multiplies by 1000 to get 1700000000000 milliseconds. The UTC date constructed from that value is 2023-11-14 22:13:20 UTC, so that is the primary human-readable result. The supporting rows show the ISO 8601 UTC string 2023-11-14T22:13:20.000Z, the milliseconds since epoch, and the mode label. The note states that Unix time counts elapsed seconds from the Unix epoch in UTC.

Switch to UTC date to timestamp and enter 2023-11-14T22:13:20Z. The calculator parses the text, gets 1700000000000 milliseconds, truncates milliseconds ÷ 1000 to 1700000000, and returns that as the Unix timestamp. If the date text has no zone, such as 2023-11-14T22:13:20, the calculator appends UTC rather than using your local setting.

Reference table

The table is useful for checking units. If a value around 1700000000000 is entered as seconds, it will not land in 2023; it is almost certainly a millisecond timestamp that needs division by 1000 before classic Unix handling.

Programming and data domains

Unix timestamps are popular because numbers are easy to sort, compare, index, and store. A database can ask for all rows after one timestamp. An API can send an expiration time without worrying about the client’s local clock format. A log pipeline can merge events from servers in different countries as long as all systems agree on UTC instants.

For scheduling and user-facing calendars, the timestamp is only part of the story. A user still expects a local date, a time zone, and sometimes daylight saving behavior. Convert the timestamp to a UTC instant first, then apply the display zone intentionally. Do not compare a UTC timestamp with local text unless the offset or zone has been accounted for.

Pitfalls to avoid

Do not confuse seconds and milliseconds. Do not assume a local time zone when date text omits one; this calculator assumes UTC, while some programming libraries assume local time. Do not expect a leap-second display such as 23:59:60 from ordinary Unix tools. Do not round fractional seconds if event ordering matters; the calculator truncates in date-to-timestamp mode, so a fractional input can lose subsecond detail. Finally, remember that the Unix epoch is not the beginning of time or computing history. It is simply a convenient zero point used by Unix-like systems and many later platforms.

Sources

• IETF, RFC 3339 — Internet timestamp profile using UTC indicators, numeric offsets, and fractional seconds.
• NIST, Time and Frequency Division time services — authoritative timekeeping context from a national standards laboratory.
• BIPM, SI base units — official context for the second as the SI base unit of time.