Unix Timestamp Converter

Convert any Unix timestamp to a human-readable date and time — or turn any date back into a timestamp — instantly, in any timezone. Supports all timestamp formats: 10-digit (seconds), 13-digit (milliseconds), 16-digit (microseconds), and 19-digit (nanoseconds). No account needed, no rate limits. Just paste and convert.

Convert Timestamp to Datetime

Paste your Unix timestamp below and instantly see the corresponding date and time in any timezone.

Seconds since Jan 01 1970 (UTC)

Datetime to Timestamp Converter

Select any date and time to generate the corresponding Unix timestamp for your applications and databases.

What is a Unix timestamp?

A Unix timestamp — also called epoch time, POSIX time, or Unix time — is the number of seconds that have elapsed since January 1, 1970, at 00:00:00 UTC. This starting point is called the Unix epoch.

It's one of the most widely used ways to represent time in software because it's timezone-neutral, language-agnostic, and trivially easy to compare, sort, and do arithmetic on. A timestamp is just a number — no formatting ambiguity, no locale differences.

Example: The Unix timestamp 1700000000 corresponds to November 14, 2023, 22:13:20 UTC.

Seconds vs milliseconds vs microseconds — which do you have?

Not all Unix timestamps are the same length. The number of digits tells you the unit:

Digits	Unit	Example	Typical use
10	Seconds	`1700000000`	Linux/Unix systems, most databases, APIs
13	Milliseconds	`1700000000000`	JavaScript (Date.now()), browser events, logs
16	Microseconds	`1700000000000000`	High-precision logging, financial systems
19	Nanoseconds	`1700000000000000000`	System clocks, Go's time.Now().UnixNano()

Our converter auto-detects the format based on digit count, so you can paste any timestamp and get the right result without manually selecting the unit.

How to convert a Unix timestamp to a date (in common languages)

If you need to do this programmatically rather than with a tool, here are the one-liners for the most common languages and environments:

JavaScript

// Seconds to date
new Date(1700000000 * 1000).toISOString()
// → "2023-11-14T22:13:20.000Z"

// Milliseconds to date (Date.now() format)
new Date(1700000000000).toISOString()
// → "2023-11-14T22:13:20.000Z"

Python

from datetime import datetime, timezone

# Seconds
datetime.fromtimestamp(1700000000, tz=timezone.utc)
# → datetime(2023, 11, 14, 22, 13, 20, tzinfo=datetime.timezone.utc)

# Milliseconds
datetime.fromtimestamp(1700000000000 / 1000, tz=timezone.utc)

PHP

// Seconds
date('Y-m-d H:i:s', 1700000000);
// → "2023-11-14 22:13:20"

MySQL

-- Seconds
SELECT FROM_UNIXTIME(1700000000);
-- → 2023-11-14 22:13:20

Go

// Seconds
time.Unix(1700000000, 0).UTC()

// Nanoseconds
time.Unix(0, 1700000000000000000).UTC()

FAQs

Unix Time, also called Epoch Time or POSIX time, is basically a count of seconds that have passed since January 1, 1970 00:00:00, at midnight UTC. It's a simple way to represent time that works the same across all systems, programming languages, and timezones. That's why developers and databases use it everywhere.

Unix timestamps don't care about time zones, they're super easy to store and compare, and they work the same way in every programming language. Whether you're logging events, scheduling tasks, or storing dates in a database, timestamps just work without the headache of timezone conversions.

Honestly? Nothing. They're the exact same thing. Epoch time, Unix time, POSIX time, Unix timestamp. They all mean the same thing: seconds since January 1, 1970 00:00:00 UTC. People just use different names for it, but it's all counting from that same starting point.

It's a quirky issue with older systems that store Unix time using 32-bit numbers. These systems will hit their maximum value on January 19, 2038, at 03:14:07 UTC, and after this point, these systems will overflow and reset. Most modern systems use 64-bit numbers now, which gives us enough room for billions of years, so it's not something to worry about for new applications.

Count the digits. A 10-digit number like 1700000000 is in seconds — it represents a date in the present era (roughly 2001–2038). A 13-digit number like 1700000000000 is in milliseconds. If you paste a 13-digit timestamp into a seconds-based converter, you'll get a date in the year 57,000+ — a clear sign the unit is wrong. Our converter handles this automatically by detecting digit length, but it's useful to know the rule when writing code.

The current Unix timestamp changes every second, so the best way to check is to use the converter above — it shows the live count in seconds since January 1, 1970 UTC.

In code:

JavaScript: Math.floor(Date.now() / 1000)
Python: import time; int(time.time())
PHP: time()
Bash: date +%s

Yes. Negative Unix timestamps represent dates before January 1, 1970 UTC. For example, -86400 equals December 31, 1969 at 00:00:00 UTC. Most modern languages and 64-bit systems handle negative timestamps correctly, though some older 32-bit systems may not. If you're working with historical dates in a database or API, make sure your system supports negative epoch values.

Unix time does not account for leap seconds. The POSIX standard defines a day as exactly 86,400 seconds, which means leap seconds are either smeared across adjacent seconds (Google's approach) or cause a one-second ambiguity at the moment they're inserted. For most application development this doesn't matter — but if you're building systems that require sub-second precision around a leap second insertion, use a library that explicitly handles TAI (International Atomic Time) instead of relying on Unix timestamps alone.

We also offer

Online Time Duration Calculator

Punycode Converter

Explore more tools available on our platform.

Unix Timestamp Converter

Digits

Unit

Example

Typical use

Seconds

1700000000

Linux/Unix systems, most databases, APIs

Milliseconds

1700000000000

JavaScript (Date.now()), browser events, logs

Microseconds

1700000000000000

High-precision logging, financial systems

Nanoseconds

1700000000000000000

System clocks, Go's time.Now().UnixNano()