What Is a Unix Timestamp?
A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have elapsed since 00:00:00 UTC on January 1, 1970 — a reference point known as the Unix epoch. It is a single integer, which makes it timezone-independent, trivial to store, and cheap to compare.
Every modern operating system, database, and programming language can produce and consume Unix timestamps. You will see them in HTTP cookies, JWT exp and iat claims, log files, filesystem metadata (mtime, ctime), Kafka messages, and almost every REST API that carries a timestamp.
Most Unix systems count in whole seconds (a 10-digit number like 1744502400). JavaScript, Java, and many web APIs count in milliseconds (a 13-digit number like 1744502400000). Some systems — notably databases storing nanosecond precision — count microseconds or nanoseconds. This tool auto-detects the unit based on magnitude but always shows both interpretations side by side.
▶Unix Timestamp to Date: Common Formats
The converter outputs four representations for every input: your local timezone (derived from the browser), UTC, ISO 8601 (2026-04-13T00:00:00.000Z), and a human-friendly format like Apr 13, 2026, 00:00:00 UTC. ISO 8601 is the safest interchange format because it includes the offset and sorts lexically the same way it sorts chronologically.
Going the other direction, the tool accepts any ISO 8601 string, RFC 2822 date (Sun, 13 Apr 2026 00:00:00 GMT), or common natural formats, and emits the corresponding Unix seconds and milliseconds.
▶Common Pitfalls
The cheapest and most common bug is mixing units. Multiplying seconds by 1000 to get milliseconds is routine; forgetting to do so silently places your timestamp in 1970. If your date stamps look stuck around Jan 21, 1970, you have a 13-digit value being parsed as seconds.
The Year 2038 Problem
Thirty-two-bit signed integers overflow on January 19, 2038 at 03:14:07 UTC. Any system still using time_t = int32_t — embedded devices, legacy databases, old file formats — will wrap to 1901 on that date. Modern 64-bit systems extend the usable range to roughly 292 billion years in either direction, which is more than enough.
Leap Seconds
Unix time deliberately ignores leap seconds: a day is always exactly 86,400 seconds, even though astronomical UTC occasionally inserts a leap second to stay synchronized with Earth's rotation. This simplifies arithmetic but means Unix time and true UTC diverge by a handful of seconds over decades. Only high-precision timing (GPS, financial trade timestamps, astronomy) typically needs to care.
Timezones Are Not the Timestamp
A Unix timestamp has no timezone — it is always UTC by definition. When you ask JavaScript's new Date(ts * 1000).toString() what time it is, the formatted output uses the browser's local timezone, but the underlying timestamp is the same integer everywhere on Earth. Store timestamps in UTC; apply the timezone only at display time. If you need a sortable, timestamp-embedding identifier for a database primary key, generate a UUID Generator v7 — the first 48 bits are the same millisecond value this converter shows.
How to Convert a Unix Timestamp to a Date
- 1Paste the timestamp. Drop a Unix timestamp into the input field. The converter accepts seconds (10 digits) or milliseconds (13 digits) — the unit is auto-detected.
- 2Read the four formats. The tool immediately displays the value in your local timezone, UTC, ISO 8601, and a human-readable form.
- 3Convert the other way. To convert a date to a timestamp, paste an ISO 8601 or RFC 2822 string in the date field. The matching Unix seconds and milliseconds appear instantly.
- 4Copy the result. Click the copy icon next to any output to place it on your clipboard — no server round-trip required.
▶Code Examples
▶JavaScript / TypeScript
// Current timestamp in seconds
const nowSec = Math.floor(Date.now() / 1000);
// Timestamp -> Date
const date = new Date(1744502400 * 1000);
console.log(date.toISOString()); // 2026-04-13T00:00:00.000Z
// Date -> Timestamp
const ts = Math.floor(new Date('2026-04-13T00:00:00Z').getTime() / 1000);▶Python
import time
from datetime import datetime, timezone
# Current timestamp
now = int(time.time())
# Timestamp -> Date
date = datetime.fromtimestamp(1744502400, tz=timezone.utc)
print(date.isoformat()) # 2026-04-13T00:00:00+00:00
# Date -> Timestamp
ts = int(datetime(2026, 4, 13, tzinfo=timezone.utc).timestamp())▶Go
package main
import (
"fmt"
"time"
)
func main() {
// Current timestamp
now := time.Now().Unix()
// Timestamp -> Date
t := time.Unix(1744502400, 0).UTC()
fmt.Println(t.Format(time.RFC3339)) // 2026-04-13T00:00:00Z
// Date -> Timestamp
ts := time.Date(2026, 4, 13, 0, 0, 0, 0, time.UTC).Unix()
_ = now; _ = ts
}▶Bash
# Current timestamp
date +%s
# Timestamp -> Date (GNU date)
date -u -d @1744502400 +"%Y-%m-%dT%H:%M:%SZ"
# Timestamp -> Date (BSD/macOS date)
date -u -r 1744502400 +"%Y-%m-%dT%H:%M:%SZ"
# Date -> Timestamp (GNU)
date -u -d "2026-04-13T00:00:00Z" +%s▶Frequently Asked Questions
▶What is a Unix timestamp?
A Unix timestamp (also called epoch time) is the number of seconds elapsed since January 1, 1970 00:00:00 UTC. It is the standard way to represent time in programming, databases, and operating systems.
▶How do I convert a Unix timestamp to a date?
Paste your timestamp (in seconds or milliseconds) into the input field. The tool will instantly convert it to a human-readable date in your local timezone.
▶What is the difference between seconds and milliseconds timestamps?
A seconds-based timestamp has 10 digits (e.g., 1709654400) while a milliseconds-based timestamp has 13 digits (e.g., 1709654400000). JavaScript's Date.now() returns milliseconds, while most Unix systems use seconds.
▶What is the Year 2038 problem?
32-bit systems store Unix timestamps as a signed 32-bit integer, which will overflow on January 19, 2038 at 03:14:07 UTC. Modern 64-bit systems are not affected.