Unix Timestamp Converter: Seconds, Milliseconds and Dates

Learn how Unix epoch timestamps work and how to convert seconds or milliseconds into readable dates and back.

What is a Unix timestamp?

A Unix timestamp is a numeric representation of a point in time measured from January 1, 1970 at 00:00:00 UTC. It is widely used in APIs, databases, logs and programming languages.

Seconds vs. milliseconds

Unix seconds are often around ten digits for current dates, while Unix milliseconds are commonly around thirteen digits. The exact length changes over time, so use the API documentation rather than digit count alone.

How to convert an epoch timestamp

Use the Unix Timestamp Converter to enter a timestamp and select seconds or milliseconds. You can also enter a local date and convert it into both Unix units.

UTC and local time

Unix timestamps describe an instant independently of a time zone. A readable local date can look different in different locations even though the underlying timestamp is the same.

Seconds, milliseconds and date conversion

Unix time represents a point in time as an offset from the Unix epoch. APIs and databases commonly use either seconds or milliseconds, so identifying the unit is the first step when a timestamp looks incorrect. A value interpreted as seconds when it is actually milliseconds can produce a date far in the future.

When debugging an API, check the documentation before converting a value. Also remember that Unix timestamps represent an instant, while a displayed calendar date depends on the timezone used for presentation. Use the converter to move between the numeric timestamp and a human-readable date, then verify the timezone when the exact local time matters.

Unix timestamps are numbers tied to a time scale

A Unix timestamp commonly represents elapsed seconds since the Unix epoch, while many JavaScript and API systems use milliseconds. Confusing seconds and milliseconds can turn a date in the present into one thousands of times too large or too small.

Check timezone expectations separately

Unix timestamps represent an instant, while a displayed calendar date is formatted for a timezone. When debugging APIs, first confirm the unit and then confirm whether the application is showing UTC or converting to local time. For recurring jobs, daylight-saving changes can matter when moving between timestamps and human schedules.

When sharing a timestamp, state the unit if the surrounding API does not make it obvious.

Debug timestamps in three steps

When a timestamp looks wrong, first identify whether it is seconds or milliseconds, then check whether the value represents UTC-based epoch time, and finally inspect the timezone used for display. These three checks explain most apparent date shifts. Keep the raw numeric value unchanged when passing it between systems and convert only at the presentation boundary unless the API explicitly requires another unit.

A debugging example

If an API returns 1750000000 and your application displays a date far in the past or far in the future, check the unit before changing the timezone. A seconds value interpreted as milliseconds produces a very different instant. Once the unit is confirmed, check whether the display is UTC or local time. This separates data errors from presentation differences.