Epoch Timestamp Converter

Unix Epoch Reference

Everything a developer needs to work with epoch timestamps confidently — language snippets, format conversions, common gotchas, and example timestamps you can copy directly into your tests.

Get the Current Unix Timestamp in Any Language

The Unix epoch is a language-agnostic concept, but every runtime exposes it slightly differently. Here are current-timestamp snippets in the languages developers ask about most often.

// Seconds (Unix standard)
Math.floor(Date.now() / 1000)

// Milliseconds (JS default)
Date.now()

// Convert timestamp to Date
new Date(timestamp * 1000)

import time
from datetime import datetime, timezone

# Current epoch (float seconds)
time.time()

# Integer seconds
int(time.time())

# Timezone-aware conversion
datetime.fromtimestamp(ts, tz=timezone.utc)

# Current epoch
date +%s

# Epoch -> human (GNU date)
date -d @1700000000

# Epoch -> human (BSD/macOS)
date -r 1700000000

# Human -> epoch
date -d "2026-01-01 00:00:00 UTC" +%s

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM NOW())::bigint;
SELECT to_timestamp(1700000000);

-- MySQL
SELECT UNIX_TIMESTAMP();
SELECT FROM_UNIXTIME(1700000000);

-- SQLite
SELECT strftime('%s', 'now');

import "time"

// Current epoch in seconds
time.Now().Unix()

// Milliseconds
time.Now().UnixMilli()

// Epoch -> time.Time
time.Unix(1700000000, 0)

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

let secs = SystemTime::now()
    .duration_since(UNIX_EPOCH)
    .unwrap()
    .as_secs();

# Current epoch
Time.now.to_i

# Milliseconds
(Time.now.to_f * 1000).to_i

# Epoch -> Time
Time.at(1700000000)

// .NET 6+ — current epoch seconds
DateTimeOffset.UtcNow.ToUnixTimeSeconds()

// Milliseconds
DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()

// Epoch -> DateTimeOffset
DateTimeOffset.FromUnixTimeSeconds(1700000000)

// Java 8+ recommended
Instant.now().getEpochSecond()
Instant.now().toEpochMilli()

// Epoch -> Instant
Instant.ofEpochSecond(1700000000)

// Current epoch
time();

// Milliseconds
(int)(microtime(true) * 1000);

// Epoch -> human
date('Y-m-d H:i:s', 1700000000);

Common Timestamp Formats Side by Side

One moment in time can be written in many ways. Picking the wrong format is one of the most common interoperability bugs in APIs. The reference timestamp below is 1700000000 — Tuesday, 14 November 2023, 22:13:20 UTC.

Gotchas That Bite Developers

Notable Epoch Timestamps

Handy values to test boundary conditions in your code.

Best Practices

• Store UTC, display local. Persist Unix timestamps or ISO 8601 with a Zsuffix; convert to the user's zone only at render time.
• Pick a precision and document it. Mixing seconds and milliseconds in the same codebase causes 1000× bugs that are silent in dev and catastrophic in production.
• Use IANA timezone names, not offsets. America/New_York survives DST changes; UTC-05:00doesn't.
• Use 64-bit integers. The 2038 cliff is closer than you think, and embedded devices ship with multi-decade lifespans.
• Validate input ranges. Reject timestamps that fall outside a sane window (e.g. 2000–2100 for booking systems) — most bad data comes from unit-confusion bugs upstream.
• Prefer ISO 8601 on the wire.It's human-readable, sorts lexicographically, self-documents timezone, and survives every JSON parser without precision loss.