Free · Client-side · Auto Unit Detection

Timestamp to Date & Time Converter

Convert timestamp to date time online — paste any Unix timestamp and get the exact local date, UTC time, and ISO 8601 instantly. Auto-detects seconds, milliseconds, microseconds, or nanoseconds.

Auto-Detects Units
Works Both Ways
Code Snippets Included
100% Private

Timestamp → Date & Time

Runs entirely in your browser

Paste a timestamp below — the unit is detected automatically from the digit count.

Unix Timestamp

Detected: Seconds (10 digits)

Date & Time (Local) —

Date & Time (UTC) —

ISO 8601 —

Day of Week —

Relative Time —

Date & Time → Timestamp

Pick a date and time to get its Unix timestamp.

Date & Time

Unix Timestamp (Seconds) —

Unix Timestamp (Milliseconds) —

Overview

What Is a Unix Timestamp?

A Unix timestamp (or "epoch time") is just a single number: the number of seconds that have passed since January 1, 1970, 00:00:00 UTC. There's no timezone, no calendar format, no ambiguity — just a count.

That simplicity is exactly why it's everywhere: server logs, database columns, JWT tokens, video and log-file timestamps, and virtually every programming language's date/time API all use it as the underlying representation of "a moment in time."

Timezone-independent — the same number everywhere on Earth
Sorts and compares as a plain number, no parsing needed
Can be negative for dates before 1970
Comes in different precisions: seconds, milliseconds, microseconds, nanoseconds

Why Convert a Timestamp?

Raw timestamps are efficient for computers but unreadable for humans. You'll usually need to convert one when you're:

Debugging an API response or a database row that stores created_at as an integer
Reading a server or application log with epoch-stamped entries
Decoding a JWT token's iat / exp claims
Checking when a file, commit, or event actually happened

This converter handles all of these — paste the number, get the human date, no guessing at the unit required.

Reference

Timestamp Precision: Seconds, Milliseconds, Microseconds, Nanoseconds

The same moment in time looks like a different-length number depending on the precision. Here's roughly how many digits each precision has right now, and where each one shows up:

Unit	Digits (2026)	Example	Commonly Used By
Seconds	10	`1690000000`	Unix/Linux, JWT claims, most REST APIs
Milliseconds	13	`1690000000000`	JavaScript `Date.now()`, Java `currentTimeMillis()`
Microseconds	16	`1690000000000000`	Python `time.time_ns()/1000`, MongoDB, some log formats
Nanoseconds	19	`1690000000000000000`	Go `time.UnixNano()`, high-resolution tracing systems

Common Time Duration Reference

Useful when you're eyeballing a difference between two timestamps:

Duration	In Seconds
1 minute	60
1 hour	3,600
1 day	86,400
1 week	604,800
30 days	2,592,000
1 year (365 days)	31,536,000

For Developers

Convert a Timestamp to a Date in Code

The same conversion this tool does, in the language you're actually using.

const ts = 1690000000; // seconds
const date = new Date(ts * 1000); // JS Date expects milliseconds
console.log(date.toISOString()); // 2023-07-22T04:26:40.000Z
from datetime import datetime, timezone

ts = 1690000000
dt = datetime.fromtimestamp(ts, tz=timezone.utc)
print(dt.isoformat()) # 2023-07-22T04:26:40+00:00
$ts = 1690000000;
echo date('Y-m-d H:i:s', $ts); // 2023-07-22 04:26:40
import java.time.Instant;

long ts = 1690000000L; // seconds
Instant instant = Instant.ofEpochSecond(ts);
System.out.println(instant); // 2023-07-22T04:26:40Z
long ts = 1690000000; // seconds
DateTimeOffset dto = DateTimeOffset.FromUnixTimeSeconds(ts);
Console.WriteLine(dto.UtcDateTime); // 7/22/2023 4:26:40 AM
import "time"

ts := int64(1690000000)
t := time.Unix(ts, 0).UTC()
fmt.Println(t) // 2023-07-22 04:26:40 +0000 UTC
ts = 1690000000
puts Time.at(ts).utc # 2023-07-22 04:26:40 UTC
SELECT FROM_UNIXTIME(1690000000);
-- 2023-07-22 04:26:40
SELECT to_timestamp(1690000000);
-- 2023-07-22 04:26:40+00
# GNU/Linux date
date -d @1690000000 -u
# macOS / BSD date
date -r 1690000000 -u

What Is the Year 2038 Problem?

Some older systems store a Unix timestamp as a signed 32-bit integer, which can only count up to 2,147,483,647 seconds past the epoch. That number is reached at 03:14:07 UTC on January 19, 2038 — one second later, the counter overflows and wraps around to a large negative number, which those systems misread as a date back in December 1901.

This mirrors the Y2K problem, but for timestamps instead of two-digit years. Modern 64-bit systems store the same value as a signed 64-bit integer, which won't overflow for roughly another 292 billion years — so the practical risk today is mostly in older embedded systems, legacy databases, and 32-bit software that hasn't been updated.

Quick Answers

Straight Answers to Common Timestamp Questions

How do I convert timestamp to date time online?

Paste the number into the converter above. It detects the unit automatically and shows the local date, UTC date, and ISO 8601 format instantly — nothing to configure.

Is my timestamp in seconds or milliseconds?

Count the digits: 10 digits is seconds, 13 is milliseconds, 16 is microseconds, 19 is nanoseconds. The unit badge above the results confirms exactly what was detected.

Can I convert a date into a timestamp instead?

Yes — use the "Date & Time → Timestamp" section of the converter above. Pick any date and time and get the Unix timestamp in seconds and milliseconds.

FAQ

Frequently Asked Questions

Paste your timestamp into the converter above. It automatically detects whether the number is in seconds, milliseconds, microseconds, or nanoseconds, and instantly shows the matching date and time in your local timezone, in UTC, and in ISO 8601 format.

A Unix timestamp (also called epoch time) is the number of seconds that have elapsed since January 1, 1970, 00:00:00 UTC. It's a single number that unambiguously represents a moment in time, independent of timezone or calendar format, which is why it's used throughout operating systems, databases, and APIs.

Count the digits. A current Unix timestamp in seconds has 10 digits (e.g. 1690000000). The same moment in milliseconds has 13 digits (1690000000000), in microseconds 16 digits, and in nanoseconds 19 digits. This converter detects the unit automatically from the digit count, or you can set it manually with the unit selector.

Systems that store Unix time as a signed 32-bit integer can only count seconds up to 2,147,483,647 — which overflows at 03:14:07 UTC on January 19, 2038. After that instant, those systems wrap around to a negative number and misinterpret the date. Modern 64-bit systems aren't affected, since a 64-bit signed integer can represent seconds for hundreds of billions of years.

Yes. A negative Unix timestamp represents a date before the January 1, 1970 epoch. For example, -86400 is December 31, 1969. Enter a negative number into the converter above and it will resolve to the correct historical date.

Yes. Use the "Date & Time → Timestamp" section of the converter above — pick any date and time, and the equivalent Unix timestamp in both seconds and milliseconds appears instantly. Need to convert many timestamps at once instead? Try the Batch Timestamp Converter.

Explore All Free Developer Tools

UUIDs, QR codes, barcodes, image tools, converters and more — all free, all client-side.

Browse All Tools Back to Top

Timestamp to Date & Time Converter

Timestamp → Date & Time

Date & Time → Timestamp

What Is a Unix Timestamp?

Why Convert a Timestamp?

Timestamp Precision: Seconds, Milliseconds, Microseconds, Nanoseconds

Common Time Duration Reference

Convert a Timestamp to a Date in Code

What Is the Year 2038 Problem?

Straight Answers to Common Timestamp Questions

Frequently Asked Questions

How do I convert a timestamp to date time online?

What is a Unix timestamp?

How do I know if my timestamp is in seconds or milliseconds?

What is the Year 2038 problem?

Does this work for timestamps before 1970 (negative numbers)?

Can I convert a date back into a Unix timestamp?

Related Tools

Timestamp & ISO 8601

Live & Bulk

Date Calculators

Timestamps in IDs

Explore All Free Developer Tools