Unix Timestamp to Date Converter - Instant Epoch Decoder

Last updated March 22, 2026

Unix Timestamp to Date Converter — Examples

Unix timestamps are the number of seconds (or milliseconds) since January 1, 1970 UTC. Here are practical examples for converting Unix timestamps to human-readable dates in multiple languages.

Basic Conversion

// JavaScript — Unix timestamp to date
function unixToDate(timestamp) {
  // Auto-detect seconds vs milliseconds
  const ts = timestamp > 1e10 ? timestamp : timestamp * 1000;
  const date = new Date(ts);
  
  return {
    utc:     date.toUTCString(),
    iso8601: date.toISOString(),
    local:   date.toLocaleString(),
    date:    date.toISOString().split("T")[0],
    time:    date.toISOString().split("T")[1].replace("Z", " UTC")
  };
}

// Examples
console.log(unixToDate(1710000000));    // seconds
console.log(unixToDate(1710000000000)); // milliseconds

# Python — Unix timestamp to date
from datetime import datetime, timezone

def unix_to_date(timestamp):
    # Auto-detect seconds vs milliseconds
    if timestamp > 1e10:
        ts_s = timestamp / 1000
    else:
        ts_s = timestamp
    
    dt = datetime.fromtimestamp(ts_s, tz=timezone.utc)
    
    return {
        "utc": dt.strftime("%Y-%m-%d %H:%M:%S UTC"),
        "iso8601": dt.isoformat(),
        "date": dt.strftime("%B %d, %Y"),
        "time": dt.strftime("%H:%M:%S UTC")
    }

print(unix_to_date(1710000000))    # seconds
print(unix_to_date(1710000000000)) # milliseconds

Timezone Conversion

// JavaScript — convert Unix timestamp to multiple timezones
function unixToTimezones(unixSeconds) {
  const date = new Date(unixSeconds * 1000);
  
  const timezones = [
    "UTC",
    "America/New_York",
    "America/Los_Angeles",
    "Europe/London",
    "Europe/Paris",
    "Asia/Tokyo",
    "Australia/Sydney"
  ];
  
  const results = {};
  timezones.forEach(tz => {
    results[tz] = date.toLocaleString("en-US", {
      timeZone: tz,
      year: "numeric",
      month: "2-digit",
      day: "2-digit",
      hour: "2-digit",
      minute: "2-digit",
      second: "2-digit",
      timeZoneName: "short"
    });
  });
  
  return results;
}

console.log(unixToTimezones(1710000000));

# Python — convert Unix timestamp to multiple timezones
from datetime import datetime, timezone
import zoneinfo

def unix_to_timezones(unix_seconds):
    dt_utc = datetime.fromtimestamp(unix_seconds, tz=timezone.utc)
    
    timezones = [
        "UTC",
        "America/New_York",
        "America/Los_Angeles",
        "Europe/London",
        "Asia/Tokyo",
    ]
    
    results = {}
    for tz_name in timezones:
        tz = zoneinfo.ZoneInfo(tz_name)
        dt_local = dt_utc.astimezone(tz)
        results[tz_name] = dt_local.strftime("%Y-%m-%d %H:%M:%S %Z")
    
    return results

print(unix_to_timezones(1710000000))

Reverse: Date to Unix Timestamp

// JavaScript — date string to Unix timestamp
function dateToUnix(dateStr, timezone = "UTC") {
  const date = new Date(dateStr);
  return {
    seconds: Math.floor(date.getTime() / 1000),
    milliseconds: date.getTime()
  };
}

// Examples
console.log(dateToUnix("2024-03-09T16:00:00Z"));
console.log(dateToUnix("2024-01-01"));
console.log(dateToUnix("2024-12-31T23:59:59Z"));

# Python — date to Unix timestamp
from datetime import datetime, timezone

def date_to_unix(date_str):
    """Convert an ISO 8601 date string to Unix timestamp."""
    dt = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
    if dt.tzinfo is None:
        dt = dt.replace(tzinfo=timezone.utc)
    
    return {
        "seconds": int(dt.timestamp()),
        "milliseconds": int(dt.timestamp() * 1000)
    }

print(date_to_unix("2024-03-09T16:00:00Z"))
print(date_to_unix("2024-01-01"))

Seconds vs Milliseconds Detection

// Automatically detect if a timestamp is in seconds or milliseconds
function detectPrecision(timestamp) {
  // Unix timestamps in seconds are 10 digits (until year 2286)
  // Unix timestamps in milliseconds are 13 digits
  
  const ts = Number(timestamp);
  
  if (ts > 1e12) {
    return {
      precision: "milliseconds",
      seconds: Math.floor(ts / 1000),
      date: new Date(ts).toISOString()
    };
  } else {
    return {
      precision: "seconds",
      milliseconds: ts * 1000,
      date: new Date(ts * 1000).toISOString()
    };
  }
}

console.log(detectPrecision(1710000000));    // seconds
console.log(detectPrecision(1710000000000)); // milliseconds

Common Unix Timestamps

// Reference timestamps
const references = {
  "Unix epoch":        0,           // 1970-01-01 00:00:00 UTC
  "Y2K":               946684800,   // 2000-01-01 00:00:00 UTC
  "Year 2038 problem": 2147483647,  // 2038-01-19 03:14:07 UTC (max 32-bit)
  "Now (approx)":      1710000000,  // March 2024
};

Object.entries(references).forEach(([label, ts]) => {
  const date = new Date(ts * 1000);
  console.log(`${label}: ${date.toISOString()}`);
});

Database Usage

-- SQL — convert Unix timestamps in database queries

-- MySQL
SELECT FROM_UNIXTIME(1710000000) AS date_utc;
SELECT UNIX_TIMESTAMP('2024-03-09 16:00:00') AS unix_ts;

-- PostgreSQL
SELECT TO_TIMESTAMP(1710000000) AT TIME ZONE 'UTC' AS date_utc;
SELECT EXTRACT(EPOCH FROM '2024-03-09 16:00:00'::TIMESTAMP) AS unix_ts;

-- SQLite
SELECT DATETIME(1710000000, 'unixepoch') AS date_utc;
SELECT STRFTIME('%s', '2024-03-09 16:00:00') AS unix_ts;

Relative Time Display

// Show how long ago or how far in the future a timestamp is
function relativeTime(unixSeconds) {
  const diffMs = Date.now() - unixSeconds * 1000;
  const diffSeconds = Math.abs(Math.floor(diffMs / 1000));
  const past = diffMs > 0;
  
  let label;
  if (diffSeconds < 60)        label = `${diffSeconds} seconds`;
  else if (diffSeconds < 3600) label = `${Math.floor(diffSeconds / 60)} minutes`;
  else if (diffSeconds < 86400) label = `${Math.floor(diffSeconds / 3600)} hours`;
  else if (diffSeconds < 2592000) label = `${Math.floor(diffSeconds / 86400)} days`;
  else if (diffSeconds < 31536000) label = `${Math.floor(diffSeconds / 2592000)} months`;
  else label = `${Math.floor(diffSeconds / 31536000)} years`;
  
  return past ? `${label} ago` : `in ${label}`;
}

console.log(relativeTime(1710000000)); // e.g., "3 days ago"

The Unix Timestamp to Date Converter handles both second and millisecond precision, all timezones, and both directions (timestamp to date and date to timestamp). It's an essential tool for any developer working with time-based data.