Unix Timestamp Converter -- Epoch to Date

What Is a Unix Timestamp?

A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have elapsed since January 1, 1970, 00:00:00 UTC — a reference point known as the Unix epoch. It is the standard way computers represent a point in time as a single number.

For example, the timestamp 1700000000 represents November 14, 2023 at 22:13:20 UTC. The timestamp 0 represents the epoch itself: January 1, 1970 at midnight UTC.

Why developers use Unix timestamps

• Timezone-independent: A timestamp always represents the same instant worldwide. No ambiguity about time zones, daylight saving, or date formats.
• Easy to compare: To check which event happened first, compare two integers. No date parsing needed.
• Simple arithmetic: Add 86,400 to get the same time tomorrow. Subtract two timestamps to get the difference in seconds.
• Compact storage: A single 32-bit or 64-bit integer vs. separate year, month, day, hour, minute, second fields.
• Universal support: Every programming language, database, and operating system understands Unix timestamps.

Seconds vs. Milliseconds Timestamps

Some systems store timestamps in seconds (10 digits), others in milliseconds (13 digits). Confusing the two is one of the most common timestamp bugs.

Quick rule: If the number is 13 digits, divide by 1,000 to get seconds. If it is 10 digits, it is already in seconds.

Common Date Formats

This converter outputs timestamps in several standard formats. Here is what each one means:

Tip: For APIs and data storage, use ISO 8601 or Unix timestamps. For display to users, use local time with explicit timezone indication.

Getting Timestamps in Code

// Current timestamp (seconds)
Math.floor(Date.now() / 1000)

// Timestamp to date
new Date(1700000000 * 1000)

// Date to timestamp
Math.floor(new Date('2023-11-14').getTime() / 1000)

import time
from datetime import datetime

# Current timestamp (seconds)
int(time.time())

# Timestamp to date
datetime.utcfromtimestamp(1700000000)

# Date to timestamp
int(datetime(2023, 11, 14).timestamp())

# Current timestamp
date +%s

# Timestamp to date
date -d @1700000000        # Linux
date -r 1700000000         # macOS

# Specific date to timestamp
date -d '2023-11-14' +%s   # Linux

-- Current timestamp (MySQL)
SELECT UNIX_TIMESTAMP();

-- Timestamp to date (MySQL)
SELECT FROM_UNIXTIME(1700000000);

-- Current timestamp (PostgreSQL)
SELECT EXTRACT(EPOCH FROM NOW())::int;

-- Timestamp to date (PostgreSQL)
SELECT TO_TIMESTAMP(1700000000);

Notable Timestamps

The Year 2038 Problem (Y2K38)

Many older systems store Unix timestamps as 32-bit signed integers. The maximum value a 32-bit signed integer can hold is 2,147,483,647, which corresponds to January 19, 2038 at 03:14:07 UTC.

One second later, the value overflows to −2,147,483,648, which the system interprets as December 13, 1901. This can cause crashes, data corruption, and incorrect date calculations in affected software.

The fix: Modern systems use 64-bit integers for timestamps. A 64-bit signed integer can represent dates up to approximately 292 billion years in the future — far beyond any practical need. Most current operating systems, databases, and programming languages have already migrated to 64-bit timestamps.

Who is still at risk? Embedded systems, legacy firmware, and older 32-bit applications that have not been updated. If you maintain systems that store timestamps as 32-bit integers, plan the migration before 2038.

Common Mistakes

• Confusing seconds and milliseconds: A 13-digit number is milliseconds; a 10-digit number is seconds. Feeding milliseconds into a function expecting seconds gives a date tens of thousands of years in the future.
• Ignoring time zones: Timestamps are always UTC. Converting to a local date without applying the correct timezone offset produces wrong results. Always use timezone-aware date functions.
• Assuming all months are 30 days: To add "one month" to a timestamp, don't just add 2,592,000 seconds (30 days). Use a proper date library that handles varying month lengths and leap years.
• Storing timestamps as strings: A timestamp is a number. Storing it as a string wastes space and makes comparisons slower. Use integer columns in databases.
• Not handling negative timestamps: Dates before January 1, 1970 are valid and represented as negative numbers (e.g., −86400 = December 31, 1969). Some older libraries fail on negative values.
• Using local time for storage: Store timestamps in UTC. Convert to local time only for display. Mixing local times from different timezones in the same database leads to subtle, hard-to-find bugs.

When to Use Unix Timestamps vs. Other Formats

Frequently Asked Questions

What is a Unix timestamp?

A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have elapsed since January 1, 1970, 00:00:00 UTC — a reference point known as the Unix epoch. For example, the timestamp 1700000000 represents November 14, 2023 at 22:13:20 UTC. Timestamps are timezone-independent, making them the standard way to represent time in computing.

How do I convert a Unix timestamp to a readable date?

Enter the timestamp into the converter above for instant results. In code: in JavaScript, use new Date(timestamp * 1000) (JavaScript uses milliseconds). In Python, use datetime.fromtimestamp(timestamp). In a terminal, run date -d @1700000000 on Linux or date -r 1700000000 on macOS.

How do I convert a date to a Unix timestamp?

Use the "Date → Unix Timestamp" panel above. In code: in JavaScript, Math.floor(new Date('2023-11-14').getTime() / 1000). In Python, int(datetime(2023, 11, 14).timestamp()). In a terminal, date -d '2023-11-14' +%s on Linux.

What is the difference between seconds and milliseconds timestamps?

A seconds-based timestamp is 10 digits (e.g., 1700000000). A milliseconds-based timestamp is 13 digits (e.g., 1700000000000). JavaScript, Java, and some APIs use milliseconds. Unix/Linux, Python, PHP, and most databases use seconds. To convert: divide milliseconds by 1,000 to get seconds, or multiply seconds by 1,000 to get milliseconds.

What is the Year 2038 problem?

Many older systems store Unix timestamps as 32-bit signed integers. The maximum value is 2,147,483,647, which corresponds to January 19, 2038 at 03:14:07 UTC. After this moment, the timestamp overflows to a negative number, which is interpreted as a date in December 1901. Modern 64-bit systems are not affected — they can represent dates billions of years into the future.

Why do Unix timestamps start from 1970?

January 1, 1970 was chosen when Unix was being developed at Bell Labs in the early 1970s. The date was recent enough to be practical for the computing needs of the time, and it has since become the universal reference point for time in computing across virtually all operating systems and programming languages.

Can Unix timestamps represent dates before 1970?

Yes. Dates before the epoch are represented as negative numbers. For example, December 31, 1969 at 23:59:59 UTC is timestamp -1. January 1, 1960 would be approximately -315619200. Most modern languages handle negative timestamps correctly, though some legacy systems may not support them.

What is ISO 8601?

ISO 8601 is an international standard for date and time representation. The format is YYYY-MM-DDTHH:mm:ss.sssZ, where T separates the date and time, and Z indicates UTC. Example: 2023-11-14T22:13:20.000Z. It is the recommended format for APIs and data interchange because it is unambiguous, sortable as text, and includes timezone information.

How do I get the current Unix timestamp?

Click the "Now" button in the converter above. In code: JavaScript — Math.floor(Date.now() / 1000). Python — int(time.time()). PHP — time(). Terminal — date +%s. The current timestamp is also displayed live at the top of this page.

Does this converter store my data?

No. All conversions run entirely in your browser using JavaScript. No timestamps or dates are sent to any server. Nothing is stored or logged.

Related Tools

• Date Difference Calculator — calculate the number of days, weeks, or months between two dates
• Time Zone Converter — convert times between different time zones
• Date Add/Subtract Calculator — add or subtract days, weeks, or months from a date
• Crontab Generator — generate cron schedule expressions for automated tasks
• Countdown Timer — set a timer to a specific date and time
• Unix Timestamps Explained — in-depth guide to epoch time, conversions, and programming examples

Privacy & Limitations

• Client-side only. No data is sent to any server. No cookies, no tracking of timestamps or dates entered. All conversions run in your browser using JavaScript.
• JavaScript precision. JavaScript numbers are 64-bit floating point (IEEE 754). Timestamps are accurate to millisecond precision. Extremely large timestamps (beyond year 275,760) may lose precision.
• Local time depends on your browser. The "Local" format uses your browser's timezone and locale settings. If your system clock or timezone is configured incorrectly, local time output will be wrong. UTC and ISO 8601 outputs are not affected.
• Leap seconds are not modeled. Unix time does not count leap seconds. Each day is exactly 86,400 seconds. This matches the behavior of virtually all computer systems but differs slightly from astronomical time (UTC).

Unix Timestamp Converter FAQ