As a developer, you deal with date and time formats constantly. One of the most common ways computers store and transmit date-time values is using Unix Epoch Timestamps.
While timestamps are efficient for databases and API responses, they are completely illegible to humans. In this guide, we'll explain how Unix epoch time works under the hood, how to convert timestamps across 10 different programming languages, and how to do it instantly in your browser.
Use our free Unix Epoch Timestamp Converter to convert epochs to UTC/local dates and calculate times in one click.
Launch Unix Epoch Converter →What is Unix Epoch Time?§
Unix Epoch Time (also known as POSIX time or Unix timestamp) is a system for describing a point in time defined as the number of seconds that have elapsed since Thursday, January 1, 1970, at 00:00:00 Coordinated Universal Time (UTC).
Because Unix time counts elapsed seconds, it is unaffected by timezones or daylight saving changes, making it incredibly stable for system logs, database indexes, and network payloads.
Seconds vs. Milliseconds§
While the classic Unix timestamp counts in seconds (typically a 10-digit number like 1784347200), many modern platforms—including JavaScript and Java—utilize milliseconds (a 13-digit number like 1784347200000) for higher precision.
Timezone Calculations and Epochs§
A common misconception is that Unix timestamps store timezone offsets. They do not. A Unix timestamp is always based on Coordinated Universal Time (UTC).
When you convert a timestamp to a local date string, the conversion engine (such as your browser or OS) applies your local system timezone offset to the UTC timestamp.
Example: Epoch `1784347200`§
- UTC (GMT):
2026-07-18 12:00:00 - EST (UTC-5):
2026-07-18 07:00:00 - CET (UTC+1):
2026-07-18 13:00:00 - IST (UTC+5.5):
2026-07-18 17:30:00
How to Convert Unix Epoch in Code (10 Languages)§
Here is how you can convert Unix timestamps to human-readable dates across 10 major programming environments:
1. JavaScript / Node.js§
// Seconds to Human-Readable Date
const timestampSeconds = 1784347200;
const date = new Date(timestampSeconds * 1000);
console.log(date.toUTCString()); // Output: "Sat, Jul 18 2026 12:00:00 GMT"
// Current Unix Timestamp (in seconds)
const currentEpoch = Math.floor(Date.now() / 1000);
2. Python§
from datetime import datetime
# Epoch to datetime object
timestamp = 1784347200
dt_object = datetime.fromtimestamp(timestamp)
print("Local Date:", dt_object)
print("UTC Date:", datetime.utcfromtimestamp(timestamp))
3. Go (Golang)§
package main
import (
"fmt"
"time"
)
func main() {
tm := time.Unix(1784347200, 0)
fmt.Println(tm.UTC().Format(time.RFC1123))
}
4. Java§
import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
public class Main {
public static void main(String[] args) {
long seconds = 1784347200L;
Instant instant = Instant.ofEpochSecond(seconds);
System.out.println(instant.toString()); // UTC representation
}
}
5. C# (.NET)§
using System;
class Program {
static void Main() {
long seconds = 1784347200;
DateTimeOffset dateTimeOffset = DateTimeOffset.FromUnixTimeSeconds(seconds);
Console.WriteLine(dateTimeOffset.UtcDateTime);
}
}
6. PHP§
<?php
$timestamp = 1784347200;
echo date('Y-m-d H:i:s', $timestamp); // Uses PHP default timezone
?>
7. Ruby§
timestamp = 1784347200
time = Time.at(timestamp)
puts time.utc
8. Rust§
use std::time::{Duration, UNIX_EPOCH};
fn main() {
let seconds = 1784347200;
let d = UNIX_EPOCH + Duration::from_secs(seconds);
println!("{:?}", d);
}
9. Swift§
import Foundation
let timestamp: TimeInterval = 1784347200
let date = Date(timeIntervalSince1970: timestamp)
print(date)
10. PostgreSQL & MySQL§
-- PostgreSQL
SELECT to_timestamp(1784347200);
-- MySQL
SELECT FROM_UNIXTIME(1784347200);
The Year 2038 Problem (Y2K38)§
Many older systems store Unix timestamps using signed 32-bit integers. The maximum value that can be represented by a signed 32-bit integer is 2,147,483,647.
On Tuesday, January 19, 2038, at 03:14:07 UTC, the number of seconds since January 1, 1970, will exceed this limit. When this happens, 32-bit systems will roll over into negative values, interpreting the date as December 13, 1901. Modern operating systems and databases are resolving this by transitioning to 64-bit integer formats, which will not overflow for another 292 billion years.
Troubleshooting Common Conversion Bugs§
1. Date is showing up in 1970§
If your date is showing up as something like Jan 18, 1970, you likely passed a seconds-based timestamp into an engine that expects milliseconds (such as JavaScript).
- Fix: Multiply your timestamp by
1000(e.g.new Date(1784347200 * 1000)).
2. Timezone offset mismatch§
If you parse a timestamp and it shows different hours on your local environment compared to your server environment:
- Fix: Always specify the timezone explicitly when formatting output, or default to formatting as UTC.
Frequently Asked Questions (FAQ)§
Q1: Does Unix time support dates before 1970?§
Yes. Dates before 1970 are represented by negative integers. For example, December 31, 1969, at 23:59:59 UTC has a timestamp of -1.
Q2: What is a leap second and how does POSIX handle it?§
Unix time does not represent leap seconds. It ignores them, repeating the last second of the day on which the leap second occurred.
Q3: How do I get the current epoch timestamp in my browser console?§
Open your console (F12) and run:
Math.floor(Date.now() / 1000)
Convert Epoch Timestamps Locally in Your Browser§
If you are debugging API responses or log outputs and need to convert timestamps instantly, you don't need to write code.
Use the NexaTools Unix Epoch Timestamp Converter. Because it runs 100% locally in your browser, your logs, timestamps, and IP address are never transmitted to any third-party servers, ensuring maximum developer privacy.