How to convert Unix Timestamp in C# and Rust?

In C# .NET use DateTimeOffset.FromUnixTimeSeconds(ts) and DateTimeOffset.UtcNow.ToUnixTimeSeconds(). In Rust use chrono::DateTime::from_timestamp(ts, 0) and SystemTime::now().duration_since(UNIX_EPOCH).

Unix Timestamp & Epoch Converter Online

Q: What is a Unix Timestamp (Epoch Time)?

A Unix Timestamp (or Epoch Time) is an integer counting the total number of seconds elapsed since Thursday, 1 January 1970 00:00:00 Coordinated Universal Time (UTC), not counting leap seconds. It is universally used in POSIX operating systems, databases, and backend APIs as a timezone-independent absolute point in time.

Q: Why did Unix Epoch start on January 1, 1970 00:00:00 UTC?

January 1, 1970 was designated by Unix engineers at Bell Labs in the early 1970s as a universal reference date that was convenient to implement across 32-bit computer architectures.

Q: How to convert timestamps in MySQL and PostgreSQL databases?

In MySQL use FROM_UNIXTIME(ts) to convert epoch to datetime, and UNIX_TIMESTAMP('2026-08-21 11:45:00') to convert date string to epoch seconds. In PostgreSQL use to_timestamp(ts) and EXTRACT(EPOCH FROM now())::bigint.

Q: What is the 'Year 2038 Problem' (Y2K38 bug) in 32-bit Unix Timestamps?

The Year 2038 Problem (Y2K38) occurs on legacy systems storing Unix time in a signed 32-bit integer (time_t). The maximum value of a signed 32-bit integer is 2,147,483,647, occurring on Tuesday, 19 January 2038 at 03:14:07 UTC. Beyond this second, the integer overflows to negative numbers (-2,147,483,648) and is misinterpreted as the year 1901. Modern systems resolve this by migrating to signed 64-bit integer architectures, which will remain valid for approximately 292 billion years.

Bidirectional conversion of Unix Timestamp to Human-Readable Date and vice versa. Includes live second-by-second Epoch ticker, millisecond (ms) support, timezone calculator (UTC, GMT, EST, PST, JST), and Year 2038 32-bit limit reference table.

Live Epoch Clock

Current Unix Epoch Timestamp (Live Running Seconds)

--seconds since Jan 1, 1970 UTC

Loading local time...•Loading UTC...

Konversi Unix Timestamp ke Date

Epoch → Date

Enter Timestamp Value

10 digits (seconds)

Input in Milliseconds (ms / 13 digits)

Local Browser Time:

UTC / GMT Standard Time:

ISO 8601 Format (JSON / APIs):

Relative Time Difference:

1 Second = 1,000 ms1 Day = 86,400 seconds

Epoch Converter: Ubah Tanggal ke Timestamp

Date → Epoch

Select Date

Select Time (HH:MM:SS)

Input TimezoneBrowser Local

Unix Timestamp (Seconds / 10 Digits):

Timestamp Milliseconds (ms / 13 Digits):

RFC 2822 Format (HTTP Header):

1 Minute = 60 seconds1 Hour = 3,600 seconds

Conversion Guide & Unix Epoch Technical Specifications

Core concepts, historical 1970 UTC foundation, and digital time representation.

Direct Answer: A Unix Timestamp (or Epoch Time) is a standardized integer tracking elapsed seconds since Thursday, 1 January 1970 00:00:00 UTC (excluding leap seconds). It is completely timezone-agnostic and immune to seasonal Daylight Saving Time shifts.

1. Epoch Reference Baseline (UTC)

POSIX specifications set 1970-01-01T00:00:00Z as integer 0. Dates before 1970 are represented by negative integers (e.g. -315619200 for 1 Jan 1960).

2. Seconds (10-Digit) vs Milliseconds (13-Digit)

Backend engines like PHP (time()) and Python (time.time()) use 10-digit seconds. Meanwhile, JavaScript (Date.now()) and Java use 13-digit milliseconds.

3. Timezone Agnostic & ISO 8601

Timestamp values are identical globally at any given moment. Differences only appear when rendered to local strings (e.g. EST = UTC-5, JST = UTC+9).

Critical Unix Timestamp Milestones & Historical Reference Table

List of historical reference points and 32-bit Year 2038 Problem (Y2K38) overflow limits. Click any row to load into converter.

Critical Unix Timestamp Milestones and 32-bit vs 64-bit Limits Table
Event / Milestone	Date & Time (UTC)	Unix Timestamp (Seconds)	Technical Significance
0 Unix Epoch Origin	1970-01-01 00:00:00 UTC	0	Baseline origin of POSIX standard time.
New Millennium (Y2K)	2000-01-01 00:00:00 UTC	946684800	Turn of the 21st century / Year 2000 milestone.
1B 1 Billion Unix Seconds	2001-09-09 01:46:40 UTC	1000000000	Celebrated 1 billionth second milestone across open source communities.
1.5B 1.5 Billion Unix Seconds	2017-07-14 02:40:00 UTC	1500000000	Mid-2010s milestone point.
2B 2 Billion Unix Seconds	2033-05-18 03:33:20 UTC	2000000000	Upcoming 2 billion seconds landmark.
32-Bit Limit (Year 2038 Problem / Y2K38)	2038-01-19 03:14:07 UTC	2147483647	Maximum signed 32-bit integer (`2^31 - 1`). 32-bit systems overflow to negative numbers (Year 1901).
Y3K Start of Year 3000 (4th Millennium)	3000-01-01 00:00:00 UTC	32503680000	Requires 64-bit integer timestamp architecture.

Practical Code Examples & Database SQL Queries

Ready-to-use implementations for Web (JS, Python, PHP, Go), Database (MySQL, PostgreSQL), and Systems (C#, Rust).

JavaScript / TypeScript

// 1. Current Timestamp (Seconds vs ms)
const tsSeconds = Math.floor(Date.now() / 1000); // 10 digits
const tsMilliseconds = Date.now();              // 13 digits

// 2. Timestamp to Date
const date = new Date(tsSeconds * 1000);
console.log(date.toISOString());   // "2026-08-21T11:45:00.000Z"
console.log(date.toLocaleString());// Browser local format

// 3. Date String to Timestamp
const timestamp = Math.floor(new Date('2026-08-21T11:45:00Z').getTime() / 1000);

Python 3

import time
from datetime import datetime, timezone

# 1. Get Current Timestamp (Integer seconds)
current_ts = int(time.time())

# 2. Timestamp to Datetime (UTC)
dt_utc = datetime.fromtimestamp(current_ts, tz=timezone.utc)
print(dt_utc.strftime('%Y-%m-%d %H:%M:%S UTC'))

# 3. ISO String to Unix Timestamp
dt = datetime.fromisoformat('2026-08-21T11:45:00+00:00')
epoch_val = int(dt.timestamp())

PHP 8+

<?php
// 1. Current Timestamp
$currentTs = time(); // or (new DateTimeImmutable())->getTimestamp()

// 2. Timestamp to Formatted Date
$formattedDate = date('Y-m-d H:i:s', $currentTs);
$dt = (new DateTime('@' . $currentTs))->setTimezone(new DateTimeZone('UTC'));
echo $dt->format('Y-m-d H:i:s T');

// 3. Date String to Timestamp
$epoch = strtotime('2026-08-21 11:45:00 UTC');
?>

Go (Golang)

package main

import (
	"fmt"
	"time"
)

func main() {
	// 1. Current Timestamp
	nowSec := time.Now().Unix()      // Seconds (int64)
	nowMs := time.Now().UnixMilli()  // Milliseconds (int64)

	// 2. Timestamp to time.Time
	tm := time.Unix(nowSec, 0).UTC()
	fmt.Println(tm.Format(time.RFC3339))

	// 3. Parse Date to Timestamp
	parsed, _ := time.Parse(time.RFC3339, "2026-08-21T11:45:00Z")
	fmt.Println(parsed.Unix())
}

MySQL / MariaDB

-- 1. Get Current Timestamp
SELECT UNIX_TIMESTAMP();
-- Output: 1710324000

-- 2. Convert Timestamp to Date (FROM_UNIXTIME)
SELECT FROM_UNIXTIME(1710324000);
-- Output: '2026-08-21 11:45:00'

-- 3. Custom Formatted Date Pattern
SELECT FROM_UNIXTIME(created_at, '%Y-%m-%d %H:%i:%s') AS formatted_date 
FROM transactions;

-- 4. Date String to Unix Timestamp
SELECT UNIX_TIMESTAMP('2026-08-21 11:45:00');

PostgreSQL

-- 1. Get Current Timestamp (EXTRACT EPOCH)
SELECT EXTRACT(EPOCH FROM now())::bigint;
-- Output: 1710324000

-- 2. Convert Timestamp to Timestamptz (to_timestamp)
SELECT to_timestamp(1710324000);
-- Output: 2026-08-21 11:45:00+00

-- 3. Convert to Specific Timezone
SELECT to_timestamp(1710324000) AT TIME ZONE 'UTC';

-- 4. Date String to Epoch Timestamp
SELECT EXTRACT(EPOCH FROM TIMESTAMP WITH TIME ZONE '2026-08-21 11:45:00Z')::bigint;

C# (.NET Core / .NET 8)

using System;

// 1. Current Timestamp (Seconds vs ms)
long currentSeconds = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
long currentMilliseconds = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

// 2. Timestamp to DateTimeOffset
DateTimeOffset dto = DateTimeOffset.FromUnixTimeSeconds(1710324000);
Console.WriteLine(dto.UtcDateTime.ToString("o")); // ISO 8601 UTC

// 3. Date String to Unix Timestamp
DateTimeOffset parsed = DateTimeOffset.Parse("2026-08-21T11:45:00Z");
long epochResult = parsed.ToUnixTimeSeconds();

Rust (Std & Chrono)

use std::time::{SystemTime, UNIX_EPOCH};
use chrono::{DateTime, Utc};

fn main() {
    // 1. Standard Library
    let start = SystemTime::now();
    let epoch_sec = start.duration_since(UNIX_EPOCH).unwrap().as_secs();

    // 2. Chrono Crate (Timestamp to Datetime)
    let dt = DateTime::from_timestamp(1710324000, 0).unwrap();
    println!("{}", dt.to_rfc3339()); // "2026-08-21T11:45:00+00:00"

    // 3. Chrono DateTime to Timestamp
    let ts = dt.timestamp();
}

Frequently Asked Questions (FAQ)

Frequently asked questions regarding Unix Epoch time, timezones, and database architecture.

What is a Unix Timestamp (Epoch Time)?

A Unix Timestamp is a standard computing integer representing the count of seconds elapsed since January 1, 1970 00:00:00 UTC. This integer allows seamless date comparisons, database indexing/sorting, and data payload exchanges across REST/GraphQL APIs without timezone ambiguity.

Why did Unix Epoch start on January 1, 1970 00:00:00 UTC?

The baseline origin of January 1, 1970 UTC was set by the creators of Unix (Dennis Ritchie and Ken Thompson) at AT&T Bell Labs as a uniform, practical, and memory-efficient digital time convention for early 32-bit hardware.

How to convert timestamps in MySQL and PostgreSQL databases?

In MySQL, use FROM_UNIXTIME(ts) to format epoch into datetime, and UNIX_TIMESTAMP(date) to convert datetime into seconds. In PostgreSQL, use to_timestamp(ts) for timestamptz conversion and EXTRACT(EPOCH FROM now())::bigint to retrieve current epoch seconds.

What is the difference between Unix Timestamp in seconds (10 digits) and milliseconds (13 digits)?

Standard POSIX systems (Linux, C, PHP, Python) use seconds (10 digits, e.g. 1710324000). Meanwhile, JavaScript and JVM engines (Java, Kotlin) use milliseconds (13 digits, e.g. 1710324000000). If you pass a 10-digit timestamp into JavaScript new Date(ts) without multiplying by 1000, it will mistakenly render in the year 1970.

What is the 'Year 2038 Problem' (Y2K38 bug) in 32-bit Unix Timestamps?

The Year 2038 Problem (Y2K38) affects legacy systems storing Unix time in a signed 32-bit integer. The maximum possible value is 2,147,483,647, which occurs on January 19, 2038 at 03:14:07 UTC. Beyond this second, integer overflow wraps the counter to negative numbers, misinterpreting the time as the year 1901. Modern systems have migrated to 64-bit integers which remain safe for hundreds of billions of years.