Developer Runs in your browser

Unix Timestamp / Epoch Converter

Convert between Unix timestamps and human-readable dates both directions. Auto-detects seconds / milliseconds / microseconds / nanoseconds with BigInt precision. Multi-epoch support: UNIX, JS ms, Windows FILETIME, LDAP/NT, NTP, Cocoa/Apple (2001), Excel serial, Mongo ObjectId. Outputs ISO 8601, RFC 2822, locale, day-of-week, relative. Batch convert thousands of rows. 100% client-side.

100% Private Works Offline Instant

Current Unix epoch

1784865153

ms: 1784865153831μs: 1784865153831000ns: 1784865153831000000

Timestamp input

Unit (auto-detect)

Epoch system

Start / end-of-period helpers (UTC, ms)

start of today (UTC)

1784851200000

end of today (UTC)

1784937599999

start of this month

1782864000000

end of this month

1785542399999

start of this year

1767225600000

end of this year

1798761599999

Code snippets (17 languages)

Show snippets

JavaScript

// Current Unix seconds
const seconds = Math.floor(Date.now() / 1000);
// Current Unix milliseconds
const ms = Date.now();
// Seconds → Date
const d = new Date(seconds * 1000);

TypeScript

const now: number = Math.floor(Date.now() / 1000);
const iso: string = new Date(now * 1000).toISOString();

Python

import time
seconds = int(time.time())         # Unix seconds
ms = int(time.time() * 1000)       # Unix milliseconds
# Seconds → datetime
from datetime import datetime
dt = datetime.utcfromtimestamp(seconds)

import "time"
now := time.Now()
seconds := now.Unix()             // Unix seconds
ms := now.UnixMilli()              // Unix milliseconds
ns := now.UnixNano()               // Unix nanoseconds
// Seconds → time
t := time.Unix(seconds, 0)

Java

long seconds = Instant.now().getEpochSecond();
long ms = System.currentTimeMillis();
// Seconds → Instant
Instant t = Instant.ofEpochSecond(seconds);

#include <time.h>
time_t seconds = time(NULL);   // Unix seconds
// Seconds → struct tm (UTC)
struct tm *utc = gmtime(&seconds);

C++

#include <chrono>
using namespace std::chrono;
auto now = system_clock::now();
auto ms = duration_cast<milliseconds>(now.time_since_epoch()).count();
auto sec = duration_cast<seconds>(now.time_since_epoch()).count();

long seconds = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
long ms = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
// Seconds → DateTime
var dt = DateTimeOffset.FromUnixTimeSeconds(seconds).UtcDateTime;

PHP

$seconds = time();                       // Unix seconds
$ms = (int)(microtime(true) * 1000);     // Unix milliseconds
// Seconds → string
echo date('c', $seconds);

Ruby

seconds = Time.now.to_i        # Unix seconds
ms = (Time.now.to_f * 1000).to_i
# Seconds → Time
t = Time.at(seconds)

Rust

use std::time::{SystemTime, UNIX_EPOCH};
let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
let seconds = now.as_secs();
let ms = now.as_millis();
let ns = now.as_nanos();

Swift

let seconds = Date().timeIntervalSince1970       // Double
let ms = Int(Date().timeIntervalSince1970 * 1000)
// Seconds → Date
let d = Date(timeIntervalSince1970: seconds)

Kotlin

val seconds = System.currentTimeMillis() / 1000
val ms = System.currentTimeMillis()
// Seconds → Instant
val t = java.time.Instant.ofEpochSecond(seconds)

Dart

final seconds = DateTime.now().millisecondsSinceEpoch ~/ 1000;
final ms = DateTime.now().millisecondsSinceEpoch;
// Seconds → DateTime
final d = DateTime.fromMillisecondsSinceEpoch(seconds * 1000, isUtc: true);

Bash

# Unix seconds
seconds=$(date +%s)
# Unix milliseconds (GNU date)
ms=$(date +%s%3N)
# Seconds → ISO 8601 (GNU date)
date -u -d @"$seconds" +%Y-%m-%dT%H:%M:%SZ

Perl

my $seconds = time();                  # Unix seconds
my $ms = int(Time::HiRes::time() * 1000);  # Unix milliseconds
# Seconds → localtime
my @t = gmtime($seconds);

Scala

val seconds = System.currentTimeMillis() / 1000L
val ms = System.currentTimeMillis()
// Seconds → Instant
val t = java.time.Instant.ofEpochSecond(seconds)

Privacy: All conversions run locally with BigInt and Intl.DateTimeFormat. History is stored in localStorage on this device only and contains metadata (never your raw input beyond a 32-char preview).

About Unix Timestamp / Epoch Converter

How to use

Enter your input in the tool above.
Adjust any options to your preference.
Use the Copy or Download buttons to save the result.
Everything happens locally — your data never leaves your browser.

FAQ

What is a Unix timestamp?

A Unix timestamp (also called Unix epoch time or POSIX time) is the number of seconds that have elapsed since 00:00:00 UTC on 1 January 1970 (the 'Unix epoch'), excluding leap seconds. It is the standard way computers represent absolute time. Most systems store it as a 32-bit signed integer, which will overflow on 19 January 2038 (the 'Y2K38' or 'Year 2038' problem).

How does this tool detect seconds vs milliseconds vs microseconds vs nanoseconds?

We look at the digit count and magnitude of the input. Roughly: 1-10 digits = seconds, 11-13 digits = milliseconds, 14-16 digits = microseconds, 17+ digits = nanoseconds. You can always override with the unit selector. All conversions are done with BigInt so microsecond and nanosecond precision is never rounded by JavaScript's 53-bit float Number.

What happens in 2038?

On 19 January 2038 at 03:14:07 UTC, the signed 32-bit Unix timestamp (2,147,483,647) will roll over to a negative number, breaking any system that stores time as a 32-bit signed int. This tool always uses BigInt internally and warns you if your input is near or beyond that boundary so you know which legacy systems would break.

Which non-Unix epochs are supported?

Windows FILETIME (100-nanosecond intervals since 1601-01-01 UTC), LDAP/NT (100-ns intervals since 1601), NTP (seconds since 1900-01-01 with a 32-bit seconds field that wraps in 2036), Apple/Cocoa (seconds since 2001-01-01 UTC), Excel serial date (days since 1899-12-30, with Excel's 1900 leap-year bug called out), and MongoDB ObjectId embedded timestamps (4-byte seconds since 1970).

What extra features does this tool have versus others?

(1) Auto unit detection (s/ms/μs/ns) with manual override. (2) BigInt precision so μs/ns never lose digits. (3) Timestamp → date AND date → timestamp both directions. (4) 6 output formats (ISO 8601, RFC 2822, locale, day-of-week, relative time, UTC + local). (5) 8 epoch systems (UNIX, JS ms, FILETIME, LDAP/NT, NTP, Cocoa, Excel serial, Mongo ObjectId). (6) Live ticking current-epoch clock in any unit. (7) Batch mode: paste thousands of timestamps, get a converted table + CSV export. (8) Start/end-of-year/month/day epoch helpers. (9) 2038 (signed 32-bit) overflow warning. (10) Code snippets for getting/converting epoch in 15+ languages. (11) Color-coded unit badge. (12) localStorage history (max 20, metadata only). (13) Shareable URL with ?ts=...&unit=... (fragment-encoded).

Is my data sent anywhere?

No. All conversions run locally with BigInt and Intl.DateTimeFormat. History is stored in localStorage on this device only and contains metadata (input length, unit, epoch kind), never your raw data.

Related tools

.bashrc / .zshrc Alias & Config Manager

Build shell aliases, functions, exports, and PATH edits in a visual editor, then export a clean, commented .aliases file sourced from both .bashrc and .zshrc — with shadowing detection against shell builtins and common CLI tools, function suggestions when args are needed, starter packs (git, docker, kubectl, navigation, safety, ls, dev, devops, data science), import of existing rc files, dedupe, history (localStorage), and shareable URL. 100% client-side.

Open

Add / Subtract Date Calculator

Add or subtract years, months, weeks, days, hours, minutes and seconds from a starting date/time. Calendar-day or business-day mode with custom weekend + holiday list. Month-end policy toggle (clamp to last day vs overflow). Repeat/series mode (e.g. every 2 weeks x 10) with CSV export. Shareable URL. 100% client-side.

Open

Age Calculator

Calculate exact age from a birth date in calendar years/months/days (no negative-day bugs) plus totals in months/weeks/days/hours/minutes/seconds. Next-birthday countdown with weekday. Feb-29 birthday policy toggle. Milestones (1,000 days, 10,000 days, 1 billion seconds). Zodiac sign + Chinese zodiac. Age gap comparison. Shareable URL. 100% client-side.

Open

All tools

Unix Timestamp / Epoch Converter

Current Unix epoch

Start / end-of-period helpers (UTC, ms)

Code snippets (17 languages)

About Unix Timestamp / Epoch Converter

How to use

FAQ

What is a Unix timestamp?

How does this tool detect seconds vs milliseconds vs microseconds vs nanoseconds?

What happens in 2038?

Which non-Unix epochs are supported?

What extra features does this tool have versus others?

Is my data sent anywhere?

Related tools

.bashrc / .zshrc Alias & Config Manager

Add / Subtract Date Calculator

Age Calculator

Search tools and actions

Current Unix epoch

Start / end-of-period helpers (UTC, ms)

Code snippets (17 languages)