Unix Timestamps in JavaScript and Python: The Complete Guide

A Unix timestamp is the number of seconds (or milliseconds) that have elapsed since 00:00:00 UTC on January 1, 1970 — a moment known as the Unix Epoch. It is the most widely used method for representing points in time in programming. Every API response, database record, log entry, and JWT token you encounter uses Unix timestamps. This guide explains exactly how to get, convert, compare, and format Unix timestamps in JavaScript and Python, covering every practical scenario.

Why Unix Timestamps?

The Unix timestamp has three properties that make it the preferred time representation in systems programming. First, it is a simple integer — trivial to store, compare, sort, and serialize. Comparing two timestamps to determine which is later is a single integer comparison. Storing a timestamp in a database requires just an integer column. Second, it is timezone-independent — Unix timestamps always represent UTC. Converting to local time happens only at display time, avoiding the entire class of bugs caused by storing times in local timezones. Third, it is universally supported — every programming language, database, and operating system has built-in support for Unix timestamps.

Getting the Current Unix Timestamp

JavaScript — seconds and milliseconds

// Milliseconds since epoch (most common in JavaScript)
const nowMs = Date.now();
// → 1746000000000

// Seconds since epoch (what most APIs and databases use)
const nowSec = Math.floor(Date.now() / 1000);
// → 1746000000

// Alternative approaches
const nowMs2 = new Date().getTime();
const nowMs3 = +new Date();  // coerce Date to number

// High-precision timestamp (microseconds, for performance measurement)
const preciseMs = performance.now();  // milliseconds since page load, not epoch

Python — seconds and milliseconds

import time
from datetime import datetime, timezone

# Seconds since epoch (float — includes sub-second precision)
now_sec = time.time()          # 1746000000.123456

# Integer seconds
now_int = int(time.time())     # 1746000000

# Milliseconds
now_ms = int(time.time() * 1000)   # 1746000000123

# Using datetime (explicit UTC — preferred for clarity)
now_utc = datetime.now(timezone.utc)
now_ts = int(now_utc.timestamp())  # 1746000000

Converting a Timestamp to a Human-Readable Date

JavaScript

const timestamp = 1746000000;  // seconds

// Create a Date object (JavaScript Date uses milliseconds)
const date = new Date(timestamp * 1000);

// Built-in formatting
date.toISOString();             // "2026-04-30T10:40:00.000Z"  (always UTC)
date.toLocaleDateString();      // "4/30/2026"  (local timezone)
date.toLocaleTimeString();      // "10:40:00 AM"
date.toLocaleString();          // "4/30/2026, 10:40:00 AM"

// Intl.DateTimeFormat — full control over formatting
const fmt = new Intl.DateTimeFormat('en-GB', {
  year: 'numeric', month: 'long', day: 'numeric',
  hour: '2-digit', minute: '2-digit', timeZoneName: 'short',
  timeZone: 'Europe/Brussels'  // ← Arun's timezone
});
fmt.format(date);
// "30 April 2026 at 12:40 CEST"

// Individual components
date.getUTCFullYear();  // 2026
date.getUTCMonth();     // 3  (0-indexed: April = 3)
date.getUTCDate();      // 30
date.getUTCHours();     // 10
date.getUTCMinutes();   // 40

Python

// From a date string
const date = new Date('2026-04-30T10:40:00Z');  // always include Z for UTC
const timestamp = Math.floor(date.getTime() / 1000);
// 1746000000

// From individual components (UTC)
const ts = Math.floor(Date.UTC(2026, 3, 30, 10, 40, 0) / 1000);
// Month is 0-indexed: April = 3

// From a local date (careful — depends on system timezone)
const localDate = new Date(2026, 3, 30, 12, 40, 0);  // noon local time
const localTs = Math.floor(localDate.getTime() / 1000);

from datetime import datetime, timezone

# From an ISO 8601 string
dt = datetime.fromisoformat('2026-04-30T10:40:00+00:00')
timestamp = int(dt.timestamp())
# 1746000000

# From explicit UTC components
dt_utc = datetime(2026, 4, 30, 10, 40, 0, tzinfo=timezone.utc)
timestamp = int(dt_utc.timestamp())

# From a naive datetime (assumed local — avoid where possible)
dt_naive = datetime(2026, 4, 30, 12, 40, 0)
timestamp = int(dt_naive.timestamp())  # treats as local timezone

// Detecting whether a timestamp is in seconds or milliseconds
function detectUnit(ts) {
  // Timestamps in seconds: roughly 1.7 billion in 2026
  // Timestamps in milliseconds: roughly 1.7 trillion in 2026
  return ts > 1e10 ? 'milliseconds' : 'seconds';
}

// Safe conversion — normalise to seconds
function toSeconds(ts) {
  return ts > 1e10 ? Math.floor(ts / 1000) : ts;
}

// Safe conversion — normalise to milliseconds
function toMilliseconds(ts) {
  return ts < 1e10 ? ts * 1000 : ts;
}

// JavaScript
const start = 1746000000;
const end = 1746086400;
const diffSeconds = end - start;               // 86400
const diffMinutes = Math.floor(diffSeconds / 60);  // 1440
const diffHours = Math.floor(diffSeconds / 3600);  // 24
const diffDays = Math.floor(diffSeconds / 86400);  // 1

// Python
diff = end_ts - start_ts  # seconds
import datetime
delta = datetime.timedelta(seconds=diff)
print(delta.days)   # 1
print(delta.total_seconds())  # 86400.0

// JavaScript
const isExpired = timestamp < Math.floor(Date.now() / 1000);
const isInFuture = timestamp > Math.floor(Date.now() / 1000);

// Python
import time
is_expired = timestamp < int(time.time())
is_in_future = timestamp > int(time.time())