Epoch Time Converter — Convert Epoch to Human Readable Date Instantly

An epoch time converter takes a raw epoch number — the count of seconds or milliseconds since January 1 1970 at 00:00:00 UTC — and converts it to a human-readable date and time string. The fastest way to convert any epoch time is the Unix Timestamp Converter — paste any value in seconds or milliseconds and get the readable date instantly with no code required.

Epoch time (also called Unix time or POSIX time) is a single integer with no year, month, day, or timezone embedded — it only becomes human-readable after a converter translates it. The conversion adds the counted seconds back to the Unix epoch reference point (January 1 1970) to produce a real date.

What Is an Epoch Time Converter?

An epoch time converter is any tool or function that translates a raw epoch value into a format humans can read — for example converting 1783941653 into "Thursday, July 17, 2026 at 12:00 PM UTC."

The conversion works in both directions:

• Epoch to human readable date — paste an epoch number, get a readable date
• Date to epoch — enter a date and time, get the corresponding epoch value

The Unix Timestamp Converter handles both directions instantly and auto-detects whether your value is in seconds (10 digits), milliseconds (13 digits), or microseconds (16 digits).

How Do You Convert Epoch Time to a Human Readable Date?

Step 1 — Check your digit count:

Step 2 — Convert to a readable date:

Use the Unix Timestamp Converter for instant no-code conversion, or use your programming language's built-in function — see the code examples below.

Step 3 — Choose your output format:

Common human-readable formats for epoch conversion output:

• ISO 8601: 2026-07-17T12:00:00Z — the international standard, always UTC
• RFC 2822: Thu, 17 Jul 2026 12:00:00 +0000 — used in email headers and HTTP
• Unix date string: Thu Jul 17 12:00:00 UTC 2026 — shell and terminal output
• Readable local: July 17, 2026 at 12:00 PM — localized display for end users

How to Convert Epoch to Human Readable Date in JavaScript

JavaScript's Date constructor expects milliseconds — multiply seconds by 1,000 first.

Seconds to human readable:

const epochSeconds = 1783941653;
const date = new Date(epochSeconds * 1000);
console.log(date.toUTCString());
console.log(date.toISOString());

Milliseconds to human readable:

const epochMs = 1783941653000;
const date = new Date(epochMs);
console.log(date.toUTCString());

Auto-detect seconds vs milliseconds:

function epochToReadable(epoch) {
  const ms = epoch.toString().length === 13 ? epoch : epoch * 1000;
  const date = new Date(ms);
  return date.toISOString();
}

console.log(epochToReadable(1783941653));
console.log(epochToReadable(1783941653000));

Custom formatted output:

const epochSeconds = 1783941653;
const date = new Date(epochSeconds * 1000);
const options = {
  year: 'numeric', month: 'long', day: 'numeric',
  hour: '2-digit', minute: '2-digit', timeZone: 'UTC'
};
console.log(date.toLocaleString('en-US', options));

How to Convert Epoch to Human Readable Date in Python

import datetime

epoch_seconds = 1783941653

dt_utc = datetime.datetime.utcfromtimestamp(epoch_seconds)
print(dt_utc)

formatted = dt_utc.strftime('%Y-%m-%d %H:%M:%S UTC')
print(formatted)

dt_explicit = datetime.datetime.fromtimestamp(
    epoch_seconds,
    tz=datetime.timezone.utc
)
print(dt_explicit.isoformat())

Convert milliseconds:

import datetime

epoch_ms = 1783941653000
epoch_seconds = epoch_ms / 1000
dt = datetime.datetime.utcfromtimestamp(epoch_seconds)
print(dt.strftime('%Y-%m-%d %H:%M:%S UTC'))

How to Convert Epoch to Human Readable Date in PHP

$epoch_seconds = 1783941653;

echo gmdate("Y-m-d H:i:s", $epoch_seconds) . " UTC\n";

echo gmdate("l, F j, Y \a\t g:i A", $epoch_seconds) . " UTC\n";

$dt = new DateTimeImmutable('@' . $epoch_seconds);
echo $dt->format('c') . "\n";

Always use gmdate() not date() — date() applies the server's local timezone producing inconsistent output across different hosting environments.

How to Convert Epoch to Human Readable Date in SQL

PostgreSQL:

SELECT TO_TIMESTAMP(1783941653) AT TIME ZONE 'UTC';

SELECT TO_CHAR(
  TO_TIMESTAMP(1783941653) AT TIME ZONE 'UTC',
  'YYYY-MM-DD HH24:MI:SS'
) AS readable_date;

MySQL:

SELECT FROM_UNIXTIME(1783941653) AS readable_date;

SELECT FROM_UNIXTIME(1783941653, '%Y-%m-%d %H:%i:%s') AS readable_date;

SQLite:

SELECT datetime(1783941653, 'unixepoch') AS readable_date;

SQL Server:

SELECT DATEADD(SECOND, 1783941653, '1970-01-01') AS readable_date;

How to Convert Epoch to Human Readable Date in Java

import java.time.Instant;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;

long epochSeconds = 1783941653L;

Instant instant = Instant.ofEpochSecond(epochSeconds);
System.out.println(instant.toString());

String formatted = DateTimeFormatter
    .ofPattern("yyyy-MM-dd HH:mm:ss")
    .withZone(ZoneOffset.UTC)
    .format(instant);
System.out.println(formatted + " UTC");

Milliseconds:

import java.time.Instant;

long epochMs = 1783941653000L;
Instant instant = Instant.ofEpochMilli(epochMs);
System.out.println(instant.toString());

How to Convert Epoch to Human Readable Date in Bash

Linux (GNU date):

date -d @1783941653 --utc '+%Y-%m-%d %H:%M:%S UTC'

macOS (BSD date):

date -r 1783941653 '+%Y-%m-%d %H:%M:%S'

Convert milliseconds in Bash:

epoch_ms=1783941653000
epoch_s=$((epoch_ms / 1000))
date -d @$epoch_s --utc '+%Y-%m-%d %H:%M:%S UTC'

How to Convert Epoch to Human Readable Date in Go

package main

import (
    "fmt"
    "time"
)

func main() {
    epochSeconds := int64(1783941653)
    t := time.Unix(epochSeconds, 0).UTC()
    fmt.Println(t.Format("2006-01-02 15:04:05 UTC"))
    fmt.Println(t.Format(time.RFC3339))
}

Human Readable Time Unit Reference

Understanding how many seconds make up common time units helps when working with epoch values:

To calculate how many days have passed since a known epoch value, subtract it from the current epoch time and divide by 86,400.

What Is the Human Readable Timestamp Format?

A human readable timestamp follows one of several standard formats:

ISO 8601 (recommended): 2026-07-17T12:00:00Z or 2026-07-17T12:00:00+00:00 — the international standard used in APIs, databases, and data exchange. The Z suffix means UTC.

RFC 2822: Thu, 17 Jul 2026 12:00:00 +0000 — used in email headers and HTTP date headers.

Unix date string: Thu Jul 17 12:00:00 UTC 2026 — output of Bash date command.

Locale-specific: July 17, 2026 at 12:00 PM — for display to end users in their local format.

Discord timestamp: Uses epoch values wrapped in markdown syntax for automatic timezone conversion for every viewer. Use the Discord Timestamp Generator to convert any epoch value to a Discord timestamp code instantly.

How Does the Epoch Time Converter Handle Negative Values?

Negative epoch values represent dates before January 1 1970. For example -86400 represents December 31, 1969 at 00:00:00 UTC — exactly one day before the Unix epoch.

Most modern programming languages handle negative epoch values correctly:

import datetime
negative_epoch = -86400
dt = datetime.datetime.utcfromtimestamp(negative_epoch)
print(dt)

const negativeEpoch = -86400;
const date = new Date(negativeEpoch * 1000);
console.log(date.toUTCString());

Older systems and 32-bit databases may not handle negative timestamps correctly — always test explicitly if your application needs to represent pre-1970 dates.

How Does Epoch Time Connect to Discord Timestamps?

Discord timestamps use epoch values directly. The Discord timestamp tag format wraps a 10-digit Unix epoch value in seconds with a format code — and Discord converts it to each viewer's local timezone automatically.

To convert any epoch value to a Discord timestamp tag:

1. Verify your epoch value is 10 digits (seconds) — divide by 1,000 if it has 13 digits
2. Go to the Discord Timestamp Generator
3. The tool accepts epoch values directly and generates all 7 Discord timestamp format codes simultaneously
4. Copy and paste into any Discord message

The Unix Timestamp Converter also converts epoch values to human-readable dates and can be used as a quick verification step before building Discord timestamp codes.

Common Mistakes to Avoid

• Passing milliseconds where seconds are expected. A 13-digit value used in TO_TIMESTAMP() in PostgreSQL or FROM_UNIXTIME() in MySQL displays a date in the year 56,000. Always divide by 1,000 first when your value is 13 digits.
• Forgetting to multiply by 1,000 in JavaScript. new Date(epochSeconds) treats the value as milliseconds — use new Date(epochSeconds * 1000) when your input is in seconds.
• Using date() instead of gmdate() in PHP. date() applies the server local timezone — use gmdate() for consistent UTC output.
• Not specifying UTC in Python. datetime.fromtimestamp() without a timezone argument uses the system local timezone — always pass tz=datetime.timezone.utc or use utcfromtimestamp().
• Displaying epoch values directly to users. Raw epoch numbers like 1783941653 are meaningless to end users — always convert to a human-readable format before display.
• Storing human-readable strings instead of epoch values. Store the raw epoch integer in databases for efficiency and timezone neutrality — convert to human-readable only at the display layer.

Related Guides

• What Is Epoch Time? Complete Guide
• Unix Timestamp — Complete Guide
• Timestamp to Date — Complete Guide
• Unix Timestamp to Date — Conversion Guide
• Date to Unix Timestamp — Complete Guide

Convert any epoch value instantly with the Unix Timestamp Converter, generate a Discord timestamp from any epoch value with the Discord Timestamp Generator, or decode any Discord Snowflake ID with the Discord Snowflake ID Decoder.