Unix Timestamps Explained: What They Are, How They Work, and How to Convert Them

Ronak Saini — Thu, 01 Oct 2026 12:36:31 +0000

If you've worked with APIs, databases, logs, or backend development, you've probably seen numbers like:

1759315200

At first glance, it doesn't look like a date.

It's actually a Unix timestamp — a way of representing a specific point in time as the number of seconds elapsed since January 1, 1970, 00:00:00 UTC.

In this article, we'll look at what Unix timestamps are, how they work, and how you can convert them into normal dates.

What is a Unix timestamp?

A Unix timestamp represents time as a number.

The Unix epoch starts at:

January 1, 1970 00:00:00 UTC

For example:

represents the beginning of the Unix epoch.

A larger number represents a later point in time.

This approach is useful because computers can easily compare and calculate numbers.

For example:

Timestamp A: 1759315200
Timestamp B: 1759401600

The difference between them can be calculated directly:

1759401600 - 1759315200 = 86400

Since there are 86,400 seconds in a day, these timestamps are exactly one day apart.

Seconds vs milliseconds

One common source of confusion is that timestamps aren't always measured in seconds.

You may encounter:

1759315200

or:

1759315200000

The first is approximately a Unix timestamp in seconds.

The second is approximately a Unix timestamp in milliseconds.

A quick way to identify them is by looking at the number of digits.

This isn't a universal rule for every possible date, but it's a useful practical shortcut.

Why are Unix timestamps useful?

Unix timestamps are commonly used in software because they make time calculations straightforward.

Some examples include:

API responses
Database records
Server logs
Authentication tokens
File metadata
Event tracking
Scheduled tasks
Programming applications

Instead of storing a formatted date such as:

October 1, 2026 18:30:00

an application can store a numeric representation and convert it into the appropriate date and timezone when displaying it.

Converting a Unix timestamp

If you have a timestamp and want to understand what date it represents, you can use a timestamp converter.

For example, a timestamp conversion tool can take:

1759315200

and convert it into a human-readable date and time.

You can also perform the reverse operation:

Date & Time → Unix Timestamp

This is particularly useful when testing APIs or working with databases.

Why timezone matters

Unix timestamps represent an instant in time, while a formatted date depends on a timezone.

For example, the same instant can be displayed differently in:

UTC
Eastern Time
Pacific Time
India Standard Time

The underlying timestamp doesn't change simply because you view it from another timezone.

Only the human-readable representation changes.

This is one reason developers often store timestamps in UTC and convert them to a user's local timezone when displaying them.

Converting timestamps while debugging

Timestamp conversion can be especially useful when debugging logs.

Imagine your server produces:

1700000000

Instead of trying to mentally decode the number, convert it into a readable date and compare it with the time an event was expected to occur.

This can help when investigating:

API requests
Database updates
Login events
Cron jobs
Server errors
Application activity

A simple example in JavaScript

JavaScript commonly works with Unix time in milliseconds.

const timestamp = 1759315200000;

const date = new Date(timestamp);

console.log(date.toISOString());

The result will be an ISO-formatted date representing that timestamp.

If you have a Unix timestamp in seconds, multiply it by 1000:

const unixSeconds = 1759315200;

const date = new Date(unixSeconds * 1000);

console.log(date.toISOString());

The multiplication is necessary because JavaScript's "Date" constructor uses milliseconds.

A simple Python example

Python provides a convenient way to convert Unix timestamps:

from datetime import datetime

timestamp = 1759315200

date = datetime.fromtimestamp(timestamp)

print(date)

If you specifically want UTC:

from datetime import datetime, timezone

timestamp = 1759315200

date = datetime.fromtimestamp(timestamp, timezone.utc)

print(date)

Try a timestamp converter

If you frequently work with timestamps, having a quick converter can save time when debugging or testing applications.

TimeStampEasy provides an online timestamp converter for converting between timestamps and readable dates and times.

You can use it here:

https://timestampeasy.com/

Final thoughts

Unix timestamps are simple once you understand the basic idea:

«A Unix timestamp is a numerical representation of a point in time relative to the Unix epoch.»

The most important things to remember are:

The Unix epoch begins on January 1, 1970 UTC.
Timestamps can use different units such as seconds or milliseconds.
The same timestamp can be displayed differently depending on timezone.
Developers commonly use timestamps in APIs, databases, logs, and applications.
A timestamp converter can make debugging and development much easier.

Once you get comfortable reading timestamps, those seemingly random numbers in API responses and server logs become much easier to understand.

How to Get Unix Timestamp in JavaScript (Seconds vs Milliseconds)

Ronak Saini — Fri, 11 Sep 2026 06:08:00 +0000

Working with dates and timestamps in JavaScript can be slightly confusing because JS handles time in milliseconds, whereas standard Unix timestamps use seconds.
Here is a quick reference guide to handle both correctly.

Get Current Timestamp in Milliseconds By default, JavaScript's Date.now() returns the current timestamp in milliseconds:const timestampMs = Date.now(); console.log(timestampMs); // Output: 1726053000000
Get Current Timestamp in Seconds (Standard Unix) To convert it to standard Unix seconds, divide by 1000 and use Math.floor():const timestampSec = Math.floor(Date.now() / 1000); console.log(timestampSec); // Output: 1726053000
Convert Unix Timestamp Back to Date If you have a Unix timestamp in seconds, multiply it by 1000 before passing it to new Date():const unixTimestamp = 1726053000; const date = new Date(unixTimestamp * 1000); console.log(date.toISOString()); Need a quick online tool to convert timestamps or test timezones? I built a fast, zero-bloat web tool to convert dates, timestamps, and timezones instantly: 👉 timestampeasy.com

DEV Community: Ronak Saini

Unix Timestamps Explained: What They Are, How They Work, and How to Convert Them

How to Get Unix Timestamp in JavaScript (Seconds vs Milliseconds)