The Timestamp Format Encyclopedia

import time
epoch = time.time()
# From epoch:
from datetime import datetime, timezone
dt = datetime.fromtimestamp(epoch, tz=timezone.utc)

from datetime import datetime, timezone
dt = datetime.now(timezone.utc)
epoch = dt.timestamp()
# From epoch:
dt = datetime.fromtimestamp(epoch, tz=timezone.utc)

dt = datetime.fromisoformat(s)
epoch = dt.timestamp()

s = dt.strftime("%Y-%m-%d %H:%M:%S")
dt = datetime.strptime(s, "%Y-%m-%d %H:%M:%S")

const ms = Date.now();
const epoch = Math.floor(ms / 1000);
// From epoch:
const d = new Date(epoch * 1000);

const d = new Date();
const epoch = Math.floor(d.getTime() / 1000);
// From epoch:
const d2 = new Date(epoch * 1000);

const s = new Date().toISOString();
const epoch = Math.floor(new Date(s).getTime() / 1000);

const ms = Date.parse("2026-04-07T15:30:45Z");
const epoch = Math.floor(ms / 1000);

Instant now = Instant.now();
long epoch = now.getEpochSecond();
// From epoch:
Instant i = Instant.ofEpochSecond(epoch);

LocalDateTime ldt = LocalDateTime.now();
long epoch = ldt.toEpochSecond(ZoneOffset.UTC);
// From epoch:
LocalDateTime l = LocalDateTime.ofEpochSecond(
  epoch, 0, ZoneOffset.UTC);

ZonedDateTime z = ZonedDateTime.now(ZoneId.of("UTC"));
long epoch = z.toEpochSecond();

long ms = System.currentTimeMillis();
long epoch = ms / 1000;

now := time.Now()
epoch := now.Unix()        // seconds
epochNs := now.UnixNano()  // nanoseconds
// From epoch:
t := time.Unix(epoch, 0)

s := time.Now().Format(time.RFC3339Nano)
t, _ := time.Parse(time.RFC3339Nano, s)
epoch := t.Unix()

use std::time::{SystemTime, UNIX_EPOCH};
let epoch = SystemTime::now()
  .duration_since(UNIX_EPOCH)
  .unwrap().as_secs();

use chrono::Utc;
let now = Utc::now();
let epoch = now.timestamp();
// From epoch:
let dt = chrono::DateTime::from_timestamp(epoch, 0);

$epoch = time();
// From epoch:
$dt = new DateTime("@$epoch");

$s = date('c'); // ISO 8601
$epoch = strtotime($s);

$epoch = microtime(true);
$dt = DateTime::createFromFormat('U.u', sprintf('%.6f', $epoch));

$epoch = strtotime("2026-04-07 15:30:45 UTC");
$s = date('Y-m-d H:i:s', $epoch);

epoch = Time.now.to_i
# From epoch:
t = Time.at(epoch).utc

require 'time'
t = Time.iso8601("2026-04-07T15:30:45Z")
epoch = t.to_i

var dt = DateTime.UtcNow;
long epoch = new DateTimeOffset(dt)
  .ToUnixTimeSeconds();
// From epoch:
var dt2 = DateTimeOffset
  .FromUnixTimeSeconds(epoch).UtcDateTime;

var dto = DateTimeOffset.UtcNow;
long epoch = dto.ToUnixTimeSeconds();
// From epoch:
var dto2 = DateTimeOffset.FromUnixTimeSeconds(epoch);

let now = Date()
let epoch = now.timeIntervalSince1970
// From epoch:
let d = Date(timeIntervalSince1970: epoch)

let fmt = ISO8601DateFormatter()
let s = fmt.string(from: Date())
let d = fmt.date(from: s)!

import kotlinx.datetime.*
val now = Clock.System.now()
val epoch = now.epochSeconds
// From epoch:
val i = Instant.fromEpochSeconds(epoch)

val ms = System.currentTimeMillis()
val epoch = ms / 1000

SELECT UNIX_TIMESTAMP(ts_col);
SELECT FROM_UNIXTIME(1775666445);

SELECT UNIX_TIMESTAMP(dt_col);
-- Only correct if dt_col is in session TZ

SELECT EXTRACT(EPOCH FROM ts_col);
SELECT to_timestamp(1775666445);

SELECT EXTRACT(EPOCH FROM ts_col);
-- Result assumes timestamp is in session TZ

// In aggregation:
{ $toLong: "$dateField" } // ms since epoch
// From epoch (ms):
new Date(1775666445123)

// The first 32 bits are epoch seconds
Timestamp(epochSeconds, ordinal)

SELECT strftime('%s', '2026-04-07 15:30:45');
SELECT datetime(1775666445, 'unixepoch');

SELECT julianday('2026-04-07 15:30:45');
SELECT strftime('%s', julianday_value);

SELECT datetime(epoch_col, 'unixepoch');
-- Direct storage: INSERT INTO t VALUES(strftime('%s','now'));

EXPIREAT mykey 1775666445
PEXPIREAT mykey 1775666445123
TTL mykey  -- remaining seconds

// In query:
{ "range": { "@timestamp": { "gte": 1775666445000 }}}
// Or ISO string in source doc

// TTL attribute must be epoch seconds:
{ "ttl": { "N": "1775666445" } }
// Enable TTL on table attribute

-- Insert with ISO or epoch ms:
INSERT INTO t (ts) VALUES (1775666445123);
INSERT INTO t (ts) VALUES ('2026-04-07T15:30:45Z');

# Python:
epoch = event["created"]
# JS:
new Date(event.created * 1000)

# Python:
from datetime import datetime
dt = datetime.fromisoformat(s)
epoch = int(dt.timestamp())

# Python:
ts = "1775666445.123456"
epoch = int(ts.split(".")[0])
# JS:
Math.floor(parseFloat(ts))

# Python:
discord_epoch = 1420070400000
ms = (snowflake >> 22) + discord_epoch
epoch = ms // 1000

# Python (boto3 returns datetime):
import calendar
epoch = calendar.timegm(dt.timetuple())

# Python (v1 RFC 2822):
from email.utils import parsedate_to_datetime
dt = parsedate_to_datetime(s)
epoch = int(dt.timestamp())

// JS:
const epoch = Math.floor(
  new Date(s).getTime() / 1000);

# Python:
from email.utils import parsedate_to_datetime
dt = parsedate_to_datetime(s)
epoch = int(dt.timestamp())

# Python:
dt = datetime.fromisoformat(s)
epoch = int(dt.timestamp())

// JS:
const epoch = timestamp.seconds;
// Or: timestamp.toDate().getTime() / 1000

# Python:
s = s.replace("+0000", "+00:00")
dt = datetime.fromisoformat(s)

# Python:
from dateutil.parser import parse
dt = parse(s)
epoch = int(dt.timestamp())

# Already epoch seconds; direct use
# For log ms:
epoch = log_ts // 1000

# Python:
dt = datetime.fromisoformat(s)
epoch = int(dt.timestamp())

# Already epoch; direct use
dt = datetime.fromtimestamp(ts, tz=timezone.utc)

# To Unix epoch (seconds):
unix_epoch = (filetime - 116444736000000000) // 10000000

# To Unix epoch:
unix_epoch = ntp_seconds - 2208988800

# To Unix epoch:
gps_epoch = 315964800  # 1980-01-06
unix = gps_epoch + (week * 604800) + tow - leap_seconds

# TAI to UTC:
utc_epoch = tai_epoch - 37  # current leap offset

# Extract ms from UUID v7:
hex_ts = uuid_str.replace("-","")[:12]
ms = int(hex_ts, 16)
epoch = ms // 1000

# Decode ULID timestamp (first 10 chars):
# Crockford base32 decode to get ms
epoch = decoded_ms // 1000