Timestamp Converter

The Unix Epoch: January 1, 1970 UTC

Unix time counts seconds elapsed since 00:00:00 UTC on 1 January 1970 (the "epoch"). This arbitrary reference point was chosen by Ken Thompson and Dennis Ritchie during early Unix development at Bell Labs.

The epoch is timezone-agnostic — it represents the same instant worldwide. A Unix timestamp of 0 equals 1970-01-01T00:00:00Z (ISO 8601) or Thu, 01 Jan 1970 00:00:00 GMT (RFC 3339).

# Unix epoch in various formats
Unix seconds:      0
Unix milliseconds: 0
ISO 8601:          1970-01-01T00:00:00.000Z
RFC 3339:          1970-01-01T00:00:00+00:00
Human (UTC):       Thursday, January 1, 1970 12:00:00 AM

Leap Seconds & Unix Time

Unix time ignores leap seconds — it assumes every day has exactly 86,400 seconds. When a positive leap second is added (e.g., 23:59:60), Unix time repeats the previous second. This keeps time monotonically increasing but means Unix time drifts from true UTC by up to 27 seconds (as of 2024).

# During a leap second (e.g., 2016-12-31)
23:59:58 UTC → Unix: 1483228798
23:59:59 UTC → Unix: 1483228799
23:59:60 UTC → Unix: 1483228799 (repeated!)
00:00:00 UTC → Unix: 1483228800

Year 2038 Problem (32-bit Integer Overflow)

32-bit signed integers max out at 2,147,483,647 (0x7FFFFFFF). This corresponds to 03:14:07 UTC on 19 January 2038. After this, 32-bit timestamps wrap to negative values (December 1901).

# 32-bit max
2147483647 → 2038-01-19 03:14:07 UTC

# 64-bit max (practically infinite)
9223372036854775807 → 292,277,026,596-12-04 15:30:07 UTC

ISO 8601 vs RFC 3339

Both are date-time interchange formats, but with key differences:

• ISO 8601: Broader — allows basic format (20231115T103000Z), week dates (2023-W46-3), ordinal dates (2023-319), time intervals, durations.
• RFC 3339: Strict profile of ISO 8601 for internet protocols — requires YYYY-MM-DDTHH:MM:SS±HH:MM or Z, forbids basic format and extensions.
• Key difference: RFC 3339 mandates : in timezone offset (+00:00); ISO 8601 allows +0000.

# ISO 8601 (all valid)
2023-11-15T10:30:00Z
2023-11-15T10:30:00+00:00
2023-11-15T10:30:00+0000
2023-W46-3
2023-319

# RFC 3339 (valid)
2023-11-15T10:30:00Z
2023-11-15T10:30:00+00:00
2023-11-15T10:30:00-05:00

# RFC 3339 (INVALID in RFC 3339, valid in ISO 8601)
2023-11-15T10:30:00+0000  ← missing colon in offset
20231115T103000Z          ← basic format

JavaScript / TypeScript

Modern Date APIs and Temporal (stage 3 proposal).

// Current epoch (seconds)
const epochSeconds = Math.floor(Date.now() / 1000);

// Current epoch (milliseconds)
const epochMs = Date.now();

// Parse any supported format
const date = new Date('2023-11-15T10:30:00Z');
const date2 = new Date(1700000000 * 1000); // from seconds

// Convert to formats
date.toISOString();           // ISO 8601: "2023-11-15T10:30:00.000Z"
date.toISOString().replace('Z', '+00:00'); // RFC 3339
date.toLocaleString();        // Human readable
date.toUTCString();           // UTC string
Math.floor(date.getTime() / 1000); // Unix seconds

// Temporal (future standard)
import { Instant } from '@js-temporal/polyfill';
const instant = Instant.now();
instant.epochSeconds;         // BigInt seconds
instant.epochMilliseconds;    // BigInt milliseconds
instant.toString();           // ISO 8601 with nanoseconds

Python

Built-in datetime and time modules.

import time
from datetime import datetime, timezone

# Current epoch (seconds, float)
epoch = time.time()
epoch_int = int(time.time())

# Current epoch (milliseconds)
epoch_ms = int(time.time() * 1000)

# Parse ISO 8601 / RFC 3339
dt = datetime.fromisoformat('2023-11-15T10:30:00+00:00')
dt = datetime.strptime('2023-11-15T10:30:00Z', '%Y-%m-%dT%H:%M:%S%z')

# From Unix timestamp
dt = datetime.fromtimestamp(1700000000, tz=timezone.utc)

# Convert to formats
dt.isoformat()                    # ISO 8601: "2023-11-15T10:30:00+00:00"
dt.strftime('%Y-%m-%dT%H:%M:%S%z') # RFC 3339-like
dt.timestamp()                    # Unix seconds (float)
int(dt.timestamp())               # Unix seconds (int)
int(dt.timestamp() * 1000)        # Unix milliseconds

# For older Python (< 3.11), use dateutil.parser
# from dateutil import parser
# dt = parser.isoparse('2023-11-15T10:30:00Z')

Go

Standard library time package with time.Time.

import (
    "fmt"
    "time"
)

func main() {
    // Current epoch (seconds)
    epoch := time.Now().Unix()

    // Current epoch (milliseconds)
    epochMs := time.Now().UnixMilli()

    // Parse RFC 3339 / ISO 8601
    t, _ := time.Parse(time.RFC3339, "2023-11-15T10:30:00Z")
    t, _ = time.Parse(time.RFC3339, "2023-11-15T10:30:00+00:00")

    // From Unix timestamp
    t = time.Unix(1700000000, 0)         // seconds
    t = time.UnixMilli(1700000000000)    // milliseconds

    // Convert to formats
    fmt.Println(t.Format(time.RFC3339))     // RFC 3339
    fmt.Println(t.Format(time.RFC3339Nano)) // RFC 3339 with nanos
    fmt.Println(t.Unix())                   // Unix seconds
    fmt.Println(t.UnixMilli())              // Unix milliseconds
    fmt.Println(t.String())                 // Human readable (local)
    fmt.Println(t.UTC().String())           // Human readable (UTC)
}

Bash / Command Line

date command (GNU coreutils / BSD) and perl/python one-liners.

# Current epoch (seconds)
date +%s

# Current epoch (milliseconds)
date +%s%3N

# Current ISO 8601 / RFC 3339
date -u +%Y-%m-%dT%H:%M:%SZ
date -u --iso-8601=seconds

# From epoch to human
date -d @1700000000
date -u -d @1700000000 +%Y-%m-%dT%H:%M:%SZ

# From ISO 8601 to epoch
date -d '2023-11-15T10:30:00Z' +%s

# From human to epoch
date -d 'Nov 15 2023 10:30:00' +%s

# Using perl (works everywhere)
perl -e 'print time, "
"'                    # epoch seconds
perl -e 'print int(time*1000), "
"'          # epoch milliseconds
perl -MPOSIX -e 'print strftime("%Y-%m-%dT%H:%M:%SZ", gmtime), "
"'  # ISO 8601

# Using python one-liner
python3 -c "import time; print(int(time.time()))"
python3 -c "from datetime import datetime; print(datetime.now().isoformat())"
python3 -c "import sys, datetime; print(int(datetime.datetime.fromisoformat(sys.argv[1]).timestamp()))" "2023-11-15T10:30:00Z"