Unix Timestamp on Daniel Zhang

Unix Timestamp in Seconds vs Milliseconds: What's the Difference?

Tue, 25 Aug 2026 10:00:00 +0800

Unix Timestamp in Seconds vs Milliseconds: What’s the Difference?

If you work with APIs, databases, logs, or backend systems, you have probably encountered Unix timestamps.

Sometimes a timestamp looks like this:

1756080000

Other times, you may see:

1756080000000

They may look similar, but they use different units.

The first timestamp is measured in seconds, while the second is measured in milliseconds.

Understanding the difference between Unix timestamps in seconds and milliseconds is important because using the wrong unit can produce a completely incorrect date.

In this guide, you’ll learn:

What a Unix timestamp is
The difference between seconds and milliseconds
Why Unix timestamps usually have 10 or 13 digits
How to tell which unit a timestamp uses
How to convert between seconds and milliseconds
Common timestamp conversion mistakes

What Is a Unix Timestamp?

A Unix timestamp represents the number of seconds that have elapsed since the Unix epoch:

1970-01-01 00:00:00 UTC

For example:

represents:

1970-01-01 00:00:00 UTC

A timestamp such as:

1756080000

represents a point in time after the Unix epoch.

Unix timestamps are widely used because they provide a simple numerical representation of time that is easy for computers to store, compare, and transmit.

However, Unix timestamps are not always represented using seconds.

Some systems use milliseconds instead.

That’s where the difference between 10-digit and 13-digit timestamps becomes important.

Unix Timestamp in Seconds

The traditional Unix timestamp uses seconds as its unit.

For example:

1756080000

means that 1,756,080,000 seconds have elapsed since:

1970-01-01 00:00:00 UTC

Most Unix timestamps representing dates around the current era are approximately 10 digits long when measured in seconds.

For example:

1756080000

Why are Unix timestamps in seconds usually 10 digits?

The Unix timestamp increases by one every second.

As time moves forward, the number gets larger:

1970 → 0
2000 → approximately 9 digits
2020 → approximately 10 digits
2025 → approximately 10 digits

This is why timestamps in seconds are commonly referred to as 10-digit Unix timestamps.

However, digit count alone should not be treated as a strict rule for every possible date.

The important thing is the unit: seconds.

Unix Timestamp in Milliseconds

A millisecond is one thousandth of a second.

Therefore:

1 second = 1,000 milliseconds

A Unix timestamp represented in milliseconds counts the number of milliseconds since the Unix epoch.

For example:

1756080000000

is the millisecond representation of:

1756080000

seconds.

Because there are 1,000 milliseconds in every second, the millisecond timestamp is usually three digits longer.

Current timestamps in milliseconds are commonly 13 digits long.

For example:

Seconds: 1756080000
Milliseconds: 1756080000000

Unix Timestamp Seconds vs Milliseconds

The simplest way to understand the difference is:

Unit	Example	Common length
Seconds	`1756080000`	10 digits
Milliseconds	`1756080000000`	13 digits

The relationship is:

milliseconds = seconds × 1000

And:

seconds = milliseconds ÷ 1000

For example:

1756080000 × 1000
= 1756080000000

So these two timestamps represent the same moment:

1756080000 seconds

and:

1756080000000 milliseconds

The only difference is the unit used to represent the time.

How to Tell If a Timestamp Is in Seconds or Milliseconds

When you encounter an unknown Unix timestamp, the number of digits can provide a useful first clue.

10-digit timestamp

A timestamp such as:

1756080000

is likely to be in seconds.

13-digit timestamp

A timestamp such as:

1756080000000

is likely to be in milliseconds.

This works well for timestamps representing dates around the present day.

However, you should not rely exclusively on the number of digits.

The safest approach is to understand the API, database, programming language, or system that produced the timestamp.

For example, different programming environments may use different timestamp units.

Why Do Some Systems Use Milliseconds?

Seconds provide enough precision for many applications.

For example, an event log might only need to record:

1756080000

But applications that need more precise timing may require milliseconds:

1756080000123

Milliseconds are useful for things such as:

Web applications
API responses
Event tracking
Performance measurements
Database records
JavaScript applications
Logs where multiple events can happen within the same second

With milliseconds, two events that happen during the same second can still be distinguished.

For example:

1756080000123
1756080000789

Both timestamps occur within the same second, but they represent different points in time.

How to Convert Seconds to Milliseconds

Converting a Unix timestamp from seconds to milliseconds is simple.

Multiply the timestamp by 1,000:

milliseconds = seconds × 1000

For example:

1756080000 × 1000

results in:

1756080000000

JavaScript example

In JavaScript, you can convert seconds to milliseconds like this:

const seconds = 1756080000;
const milliseconds = seconds * 1000;

console.log(milliseconds);

The result is:

1756080000000

How to Convert Milliseconds to Seconds

To convert milliseconds back to seconds, divide by 1,000:

seconds = milliseconds ÷ 1000

For example:

1756080000000 ÷ 1000

results in:

1756080000

In JavaScript:

const milliseconds = 1756080000000;
const seconds = milliseconds / 1000;

console.log(seconds);

If the millisecond timestamp contains a fractional remainder, you may need to decide whether to keep or discard the fractional part depending on your application’s requirements.

Common Unix Timestamp Conversion Mistakes

The most common timestamp problem is using the correct number with the wrong unit.

Mistake 1: Treating seconds as milliseconds

Suppose you have:

1756080000

and pass it directly to a JavaScript function that expects milliseconds:

new Date(1756080000);

The result will represent a date very close to the Unix epoch rather than the intended modern date.

The correct conversion is:

new Date(1756080000 * 1000);

Mistake 2: Treating milliseconds as seconds

The opposite problem can be even more obvious.

If you take:

1756080000000

and treat it as seconds, the resulting value is far outside the expected date range.

You need to divide by 1,000 first:

1756080000000 ÷ 1000
= 1756080000

Mistake 3: Assuming every timestamp has exactly 10 or 13 digits

10 and 13 digits are useful rules of thumb for modern Unix timestamps, but they are not universal rules.

Historical dates, future dates, and timestamps with different precision can have different lengths.

Always consider the source and unit of the timestamp.

Unix Timestamp in JavaScript

JavaScript is a common source of confusion because the built-in Date object uses milliseconds for Unix-style timestamps.

For example:

const timestamp = 1756080000000;

const date = new Date(timestamp);

console.log(date);

Here:

1756080000000

is interpreted as milliseconds.

If your Unix timestamp is in seconds:

const timestamp = 1756080000;

const date = new Date(timestamp * 1000);

console.log(date);

The multiplication by 1000 converts seconds into milliseconds before passing the value to Date.

Unix Timestamp in APIs and Databases

When working with APIs or databases, always check the documentation before assuming the timestamp unit.

An API might return:

{
 "created_at": 1756080000
}

or:

{
 "created_at": 1756080000000
}

Both can represent the same point in time.

The difference is simply whether the value is expressed in seconds or milliseconds.

If you’re integrating multiple systems, clearly documenting the timestamp unit can prevent subtle bugs.

For example, instead of naming a variable:

timestamp

you can make the unit explicit:

timestampSeconds

or:

timestampMilliseconds

This makes the code easier to understand and reduces the chance of accidentally mixing units.

Quick Reference

Here is a simple reference for the most common cases:

Timestamp type	Unit	Example	Conversion
Unix timestamp in seconds	Seconds	`1756080000`	`seconds × 1000`
Unix timestamp in milliseconds	Milliseconds	`1756080000000`	`milliseconds ÷ 1000`

Remember:

1 second = 1,000 milliseconds

So:

Seconds → Milliseconds
× 1000

Milliseconds → Seconds
÷ 1000

Convert Unix Timestamps Easily

If you frequently work with Unix timestamps, manually determining whether a value is in seconds or milliseconds can become inconvenient.

A timestamp converter can automatically detect common timestamp formats and convert them into human-readable dates.

For example, Unix Timestamp Converter & Epoch Pro can detect common 10-digit and 13-digit timestamps and show the corresponding date and time.

You can use it when working with:

API responses
Server logs
Database timestamps
Developer tools
Debugging
Event data

The goal is to make timestamp conversion quick without manually calculating the difference between seconds and milliseconds.

Frequently Asked Questions

What is the difference between Unix timestamps in seconds and milliseconds?

The difference is the unit of measurement.

A timestamp in seconds counts seconds since the Unix epoch, while a timestamp in milliseconds counts milliseconds since the Unix epoch.

Since one second contains 1,000 milliseconds:

milliseconds = seconds × 1000

Is a 10-digit Unix timestamp in seconds?

For modern dates, a 10-digit Unix timestamp is usually measured in seconds.

However, digit count is only a useful indication. You should verify the timestamp unit from the system or API that generated it.

Is a 13-digit Unix timestamp in milliseconds?

For modern dates, a 13-digit Unix timestamp is usually measured in milliseconds.

Again, this is a common convention rather than an absolute rule.

How do I convert a Unix timestamp from seconds to milliseconds?

Multiply the timestamp by 1,000:

milliseconds = seconds × 1000

For example:

1756080000 × 1000 = 1756080000000

How do I convert milliseconds to seconds?

Divide the timestamp by 1,000:

seconds = milliseconds ÷ 1000

For example:

1756080000000 ÷ 1000 = 1756080000

Does JavaScript use seconds or milliseconds?

JavaScript’s Date object uses milliseconds when working with Unix-style timestamps.

If you have a Unix timestamp in seconds, multiply it by 1,000 before passing it to new Date().

Conclusion

Unix timestamps can be represented using different units, but the two most common are seconds and milliseconds.

For modern timestamps:

10 digits → usually seconds
13 digits → usually milliseconds

The conversion is straightforward:

seconds × 1000 = milliseconds

milliseconds ÷ 1000 = seconds

The important thing is to always verify the unit before converting or storing a timestamp. Using seconds where milliseconds are expected, or milliseconds where seconds are expected, can produce completely incorrect dates.

Once you understand the difference, working with Unix timestamps becomes much easier.

What Is a Unix Timestamp? A Complete Guide for Developers

Mon, 24 Aug 2026 14:00:00 +0800

A Unix timestamp is a simple way to represent a specific point in time as a number.

Instead of storing a date like:

2026-08-24 14:30:00

a system can represent the same moment as:

1787553000

Unix timestamps are widely used in APIs, databases, logs, programming languages, and distributed systems because they provide a consistent, machine-friendly way to work with time.

In this guide, you’ll learn what a Unix timestamp is, why Unix time starts in 1970, the difference between seconds and milliseconds, and how to convert timestamps into readable dates.

What Is a Unix Timestamp?

A Unix timestamp represents the number of seconds that have elapsed since a specific starting point known as the Unix Epoch.

The Unix Epoch begins at:

January 1, 1970, 00:00:00 UTC

For example:

0 = January 1, 1970, 00:00:00 UTC

As time passes, the timestamp increases.

For example:

1 = January 1, 1970, 00:00:01 UTC
60 = January 1, 1970, 00:01:00 UTC
3600 = January 1, 1970, 01:00:00 UTC

Unix timestamps are also commonly called:

Unix time
Epoch time
POSIX time
Epoch timestamp

Why Does Unix Time Start on January 1, 1970?

The starting point of Unix time is called the Unix Epoch.

Instead of storing multiple values such as:

Year
Month
Day
Hour
Minute
Second

a system can store a single number representing the amount of time that has passed since a fixed starting point.

Unix chose:

January 1, 1970, 00:00:00 UTC

as that reference point.

This makes time calculations simple.

For example, if one event happened at:

1787553000

and another happened at:

1787556600

you can calculate the difference:

1787556600 - 1787553000 = 3600

The difference is:

3600 seconds = 1 hour

This simple numerical representation is one of the main reasons Unix timestamps are still widely used today.

Unix Timestamp Examples

Unix Timestamp in Seconds

The traditional Unix timestamp format uses seconds.

For example:

1787553000

This is a 10-digit Unix timestamp.

Most Unix systems and many APIs use timestamps in seconds.

In JavaScript:

Math.floor(Date.now() / 1000)

returns the current Unix timestamp in seconds.

Unix Timestamp in Milliseconds

Some programming languages and APIs use milliseconds instead.

For example:

1787553000000

This is typically a 13-digit timestamp.

The difference is:

1 second = 1,000 milliseconds

For example:

Unix timestamp in seconds:

1787553000

becomes:

Unix timestamp in milliseconds:

1787553000000

In JavaScript:

Date.now()

returns the current time in milliseconds.

This difference between seconds and milliseconds is one of the most common sources of timestamp errors.

Unix Timestamp vs. Date and Time

A Unix timestamp and a human-readable date represent the same concept: a specific moment in time.

The difference is how that information is stored or displayed.

A human-readable date might look like:

August 24, 2026, 14:30:00

A Unix timestamp might look like:

1787553000

The timestamp is easier for computers to store and compare, while the date is easier for humans to read.

This is why many systems store timestamps internally but convert them into formatted dates when displaying information to users.

How to Convert a Unix Timestamp

There are two common types of timestamp conversion.

Convert Unix Timestamp to Date

You can convert a Unix timestamp into a readable date and time.

For example:

1787553000

can be converted into a date and time in UTC or your local timezone.

The exact displayed time may differ depending on the timezone you use.

A timestamp represents one specific moment, but that moment can be displayed differently around the world.

For example:

UTC:
2026-08-24 06:30:00

Tokyo:
2026-08-24 15:30:00

New York:
2026-08-24 02:30:00

All of these represent the same moment in time.

Convert Date to Unix Timestamp

You can also convert a readable date into a Unix timestamp.

For example:

2026-08-24 14:30:00 UTC

can be converted into the number of seconds that have passed since the Unix Epoch.

This is useful when:

Working with APIs
Storing timestamps in databases
Creating scheduled tasks
Debugging logs
Comparing events
Working with backend systems

If you need to convert timestamps quickly, you can use an online Unix timestamp converter or a browser extension such as Unix Timestamp Converter & Epoch Pro.

Unix Timestamp in Different Programming Languages

JavaScript

JavaScript’s Date.now() returns the current timestamp in milliseconds.

const timestamp = Date.now();

console.log(timestamp);

To get the timestamp in seconds:

const timestamp = Math.floor(Date.now() / 1000);

console.log(timestamp);

To convert a Unix timestamp in seconds into a JavaScript Date:

const timestamp = 1787553000;

const date = new Date(timestamp * 1000);

console.log(date);

The multiplication by 1000 is necessary because JavaScript expects timestamps in milliseconds.

Python

Python provides the time and datetime modules for working with Unix timestamps.

Get the current timestamp:

import time

timestamp = time.time()

print(timestamp)

Convert a Unix timestamp into a readable date:

from datetime import datetime

timestamp = 1787553000

date = datetime.fromtimestamp(timestamp)

print(date)

For UTC:

from datetime import datetime, timezone

timestamp = 1787553000

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

print(date)

PHP

You can get the current Unix timestamp with:

$timestamp = time();

echo $timestamp;

Convert a timestamp into a formatted date:

$timestamp = 1787553000;

echo date("Y-m-d H:i:s", $timestamp);

Java

Modern Java provides the Instant class for working with Unix timestamps.

import java.time.Instant;

long timestamp = 1787553000L;

Instant instant = Instant.ofEpochSecond(timestamp);

System.out.println(instant);

For milliseconds:

Instant instant = Instant.ofEpochMilli(1787553000000L);

Common Unix Timestamp Problems

Seconds vs. Milliseconds

The most common problem is confusing timestamps in seconds with timestamps in milliseconds.

For example:

1787553000

is in seconds.

But:

1787553000000

is in milliseconds.

If you pass a seconds-based timestamp directly into a JavaScript Date object, JavaScript will interpret it as milliseconds and return a date close to January 1970.

Incorrect:

new Date(1787553000);

Correct:

new Date(1787553000 * 1000);

A useful rule of thumb is:

10 digits → usually seconds
13 digits → usually milliseconds

However, this is only a practical guideline. Always check the documentation of the API or system you are working with.

UTC vs. Local Time

Unix timestamps represent a specific moment independent of how that moment is displayed.

When converting a timestamp into a readable date, the result may be displayed in UTC or your local timezone.

This can cause confusion when debugging systems.

For example:

UTC:
2026-08-24 06:30:00

Local time:
2026-08-24 15:30:00

The timestamp is still the same.

Only the displayed timezone has changed.

When debugging timestamps, it is often useful to check both:

UTC time
Local time

Negative Unix Timestamps

Unix timestamps can also be negative.

A negative timestamp represents a moment before January 1, 1970.

For example:

-1

represents:

December 31, 1969, 23:59:59 UTC

Support for dates before 1970 can vary depending on the programming language, operating system, or library.

When Should You Use a Unix Timestamp?

Unix timestamps are useful whenever you need to store or compare a specific point in time.

Common use cases include:

API responses
Database records
Application logs
Authentication tokens
Cache expiration
Scheduled jobs
Analytics events
Server monitoring
Distributed systems

Because timestamps are numerical, they are easy to compare.

For example:

if timestamp_a > timestamp_b

then timestamp_a represents a later point in time.

This makes Unix timestamps especially useful in backend development and data processing.

Unix Timestamp FAQ

What is the Unix timestamp right now?

The current Unix timestamp is the number of seconds that have passed since January 1, 1970, 00:00:00 UTC.

You can get the current timestamp using programming languages, command-line tools, or a Unix timestamp converter.

Is Unix timestamp always in seconds?

No.

Traditional Unix timestamps are measured in seconds, but many systems use milliseconds.

For example:

10 digits → usually seconds
13 digits → usually milliseconds

Some systems may also use microseconds or nanoseconds.

Why does JavaScript use milliseconds?

JavaScript’s Date API represents timestamps in milliseconds.

That is why a Unix timestamp in seconds usually needs to be multiplied by 1000 before creating a JavaScript Date.

What is the difference between Unix time and Epoch time?

In most cases, the terms Unix time, Unix timestamp, and Epoch time are used interchangeably.

They usually refer to the number of seconds that have passed since:

January 1, 1970, 00:00:00 UTC

However, some systems may use the term “epoch” more generally to describe a custom reference point.

Can a Unix timestamp be negative?

Yes.

Negative Unix timestamps represent dates before January 1, 1970.

For example:

-1 = December 31, 1969, 23:59:59 UTC

What happens when Unix timestamps reach their limit?

Some older systems store Unix timestamps as signed 32-bit integers.

This creates the well-known Year 2038 problem, where the maximum value is reached in January 2038.

Modern systems commonly use 64-bit timestamps, which support a much larger range of dates.

Convert Unix Timestamps Quickly

Unix timestamps are simple once you understand the basic idea:

Unix timestamp = time elapsed since January 1, 1970, 00:00:00 UTC

The most important thing to watch for is the unit:

10 digits → usually seconds
13 digits → usually milliseconds

You should also pay attention to whether the converted date is displayed in UTC or your local timezone.

If you regularly work with timestamps in APIs, logs, databases, or browser-based development, Unix Timestamp Converter & Epoch Pro can help you quickly convert common Unix timestamps, automatically detect 10-digit and 13-digit formats, and view timestamps in both UTC and local time.