Unix Timestamp Converter: Convert Epoch to Date & Back

// Quick sanity-check function — invaluable when ingesting third-party data
function detectTimestampUnit(ts: number): 'seconds' | 'milliseconds' | 'microseconds' | 'unknown' {
  const digits = Math.floor(Math.abs(ts)).toString().length
  if (digits === 10) return 'seconds'
  if (digits === 13) return 'milliseconds'
  if (digits === 16) return 'microseconds'
  return 'unknown'
}

function toMilliseconds(ts: number): number {
  const unit = detectTimestampUnit(ts)
  if (unit === 'seconds')      return ts * 1000
  if (unit === 'milliseconds') return ts
  if (unit === 'microseconds') return Math.floor(ts / 1000)
  throw new Error(`Cannot normalize timestamp: ${ts} (unit unknown)`)
}

// Usage
const ts = 1745000000      // 10 digits → seconds
new Date(toMilliseconds(ts)).toISOString()  // "2026-04-18T..."

const tsMs = 1745000000000  // 13 digits → milliseconds
new Date(toMilliseconds(tsMs)).toISOString()  // same instant

// Timestamp (seconds) → ISO date string
const ts = 1745000000  // seconds
new Date(ts * 1000).toISOString()
// "2026-04-18T16:33:20.000Z"

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

// Human-readable with locale
new Date(ts * 1000).toLocaleString('en-US', {
  timeZone: 'America/New_York',
  dateStyle: 'full',
  timeStyle: 'long',
})
// "Friday, April 18, 2026 at 12:33:20 PM EDT"

// Date string → Unix timestamp (seconds)
Math.floor(new Date('2026-04-18T00:00:00Z').getTime() / 1000)
// 1744934400

// Temporal API (Stage 3 in 2026 — available in modern engines)
// import { Temporal } from '@js-temporal/polyfill'
const instant = Temporal.Instant.fromEpochSeconds(ts)
instant.toZonedDateTimeISO('America/New_York').toString()
// "2026-04-18T12:33:20-04:00[America/New_York]"

// Add duration safely (Temporal avoids DST bugs)
const later = instant.add({ hours: 36 })
later.epochSeconds  // 1745129600

from datetime import datetime, timezone, timedelta
import time

ts = 1745000000  # seconds

# Timestamp → UTC datetime
dt_utc = datetime.fromtimestamp(ts, tz=timezone.utc)
print(dt_utc.isoformat())
# "2026-04-18T16:33:20+00:00"

# Timestamp → localized datetime
from zoneinfo import ZoneInfo  # Python 3.9+
dt_ny = datetime.fromtimestamp(ts, tz=ZoneInfo("America/New_York"))
print(dt_ny.strftime('%A, %B %d %Y at %I:%M %p %Z'))
# "Saturday, April 18 2026 at 12:33 PM EDT"

# datetime → timestamp (seconds)
datetime(2026, 4, 18, tzinfo=timezone.utc).timestamp()
# 1744934400.0

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

# WRONG: omitting tz uses local time — non-reproducible
# datetime.fromtimestamp(ts)  ← depends on machine's timezone

import (
    "fmt"
    "time"
)

ts := int64(1745000000)  // seconds

// Timestamp → UTC time
t := time.Unix(ts, 0).UTC()
fmt.Println(t.Format(time.RFC3339))
// "2026-04-18T16:33:20Z"

// Timestamp → localized time
loc, _ := time.LoadLocation("America/New_York")
tNY := time.Unix(ts, 0).In(loc)
fmt.Println(tNY.Format("Monday, January 2 2006 at 3:04 PM MST"))
// "Saturday, April 18 2026 at 12:33 PM EDT"

// time.Time → Unix timestamp
t.Unix()     // 1745000000 (seconds)
t.UnixMilli()  // 1745000000000 (milliseconds)
t.UnixNano()   // 1745000000000000000 (nanoseconds)

// Current timestamp
time.Now().UTC().Unix()  // seconds since epoch

-- Seconds timestamp → timestamptz
SELECT to_timestamp(1745000000);
-- 2026-04-18 16:33:20+00

-- Convert timestamptz → Unix seconds
SELECT extract(epoch FROM '2026-04-18 16:33:20 UTC'::timestamptz)::bigint;
-- 1745000000

-- Milliseconds timestamp → timestamptz (divide by 1000 first)
SELECT to_timestamp(1745000000000 / 1000.0);

-- Current timestamp in seconds
SELECT extract(epoch FROM now())::bigint;

-- Store as bigint or timestamptz?
-- Prefer timestamptz: allows timezone-aware queries, indexes work correctly.
-- bigint forces manual conversion everywhere and is error-prone.

-- Convert a stored millisecond column to timestamptz
ALTER TABLE events ADD COLUMN created_at timestamptz;
UPDATE events SET created_at = to_timestamp(created_ms / 1000.0);

use std::time::{Duration, SystemTime, UNIX_EPOCH};

let ts: u64 = 1745000000;  // seconds

// Timestamp → SystemTime
let t = UNIX_EPOCH + Duration::from_secs(ts);

// Current Unix timestamp (seconds)
let now_secs = SystemTime::now()
    .duration_since(UNIX_EPOCH)
    .unwrap()
    .as_secs();

// For full timezone-aware formatting, use the chrono or time crate
// (std doesn't include timezone databases)

// With chrono:
use chrono::{DateTime, TimeZone, Utc};
let dt: DateTime<Utc> = Utc.timestamp_opt(ts as i64, 0).unwrap();
println!("{}", dt.to_rfc3339());
// "2026-04-18T16:33:20+00:00"

// WRONG: Date.now() returns milliseconds
const payload = {
  sub: 'user_123',
  iat: Date.now(),              // ❌ 1745000000000 — token appears created in year 57,000
  exp: Date.now() + 3600000,   // ❌ expired by 50+ years
}

// CORRECT: divide by 1000
const nowSec = Math.floor(Date.now() / 1000)
const payload = {
  sub: 'user_123',
  iat: nowSec,                 // ✅ 1745000000
  exp: nowSec + 3600,          // ✅ expires in 1 hour
}

// Validating expiry
function isTokenExpired(exp: number): boolean {
  return Math.floor(Date.now() / 1000) > exp
}

// Decode without verification (for debugging only — never trust unverified JWTs)
function decodeJwtClaims(token: string) {
  const payload = token.split('.')[1]
  const decoded = JSON.parse(atob(payload.replace(/-/g, '+').replace(/_/g, '/')))
  return {
    ...decoded,
    iat_human: new Date(decoded.iat * 1000).toISOString(),
    exp_human: new Date(decoded.exp * 1000).toISOString(),
    expired: isTokenExpired(decoded.exp),
  }
}

// Y2038 comparison by timestamp type
Type                  | Max value       | Date
─────────────────────────────────────────────────────────
int32_t (signed)      | 2,147,483,647   | 2038-01-19
uint32_t (unsigned)   | 4,294,967,295   | 2106-02-07
int64_t (signed)      | 9.2 × 10^18     | 292,277,026,596
JavaScript Number     | 9,007,199,254,740,991 (2^53-1) → ~285,616 AD

// Fix: always use 64-bit types for timestamp storage
// C:          time_t  → guaranteed 64-bit on modern glibc
// Go:         time.Time uses int64 internally
// Python:     datetime handles far-future dates fine
// JavaScript: Number is 64-bit float, safe for epoch ms until 285,616 AD
// PostgreSQL: timestamptz uses 8 bytes, covers until 294276 AD