Epoch Converter: Unix Timestamp to Date
Paste any timestamp or date and get it in words, in your time zone and in UTC, with everything else the number could be.
One number · every epoch
7 readings land on a real dateRead as Unix seconds by its length: 9 digits. As GPS seconds it would be December 6, 2005: a real date too, so it stays one click away.
- Milliseconds
- Microseconds
- Nanoseconds
- ISO 8601
Your browser's clock counts whole milliseconds: the zeros after them are padding, not precision.
UTC · UTC+00:00 on this date
1793813880- Milliseconds
1793813880000- ISO 8601
2026-11-04T17:38:00Z
Start and end in UTC
| Start | End | |
|---|---|---|
| Day | 1793750400 | 1793836799 |
| Month | 1793491200 | 1796083199 |
| Year | 1767225600 | 1798761599 |
Everything happens in this tab: nothing you paste is sent anywhere.
How to use this epoch and Unix timestamp converter
Paste the timestamp you have into the field, in whatever unit it is in, and the date appears in your own time zone and in UTC. You can also type a date, an email's Date header or the word now to get its epoch time.
As a Unix time converter it works both ways. It reads a number in seconds, milliseconds, microseconds and nanoseconds at once, picks the reading that lands on a real date, says why, and keeps the other readings one click away. Below the answer, the same digits are read as a Windows, .NET, Mac, Excel, NTP and GPS timestamp, and every format can be copied.

Paste anythingA number in any unit, an ISO date, an email's Date header, a SQL datetime or the word now. The pill says how it was read.The digits, countedThe ruler under the number groups its digits in threes, so 18 digits read as six groups: the first clue to what it is.The answer firstThe weekday and the date in words, then the time in UTC and in your own time zone, and every format to copy.Which reading, and whyThe page says in words which reading it chose and why, and names the other reading that also lands on a real date.Every other epochThe same digits read as every unit and every epoch, each a bar from its own start. Pick a row to use that reading.What is epoch time, and why does it start in 1970?
Epoch time, or Unix time, is the number of seconds since 1970-01-01 00:00:00 UTC, the moment POSIX calls the Epoch. The timestamp 0 is that moment, and 817876800 is 1995-12-02 04:00 UTC.
No primary source records why 1970 was chosen. The first Unix manual, in November 1971, counted sixtieths of a second from 1 January 1971 and noted that its clock would run out in about two and a half years; by the Seventh Edition in 1979 the count was seconds since 1 January 1970, a round date close to when Unix was being written. UTC itself only began in 1972, so earlier timestamps are UTC by convention.
full on April 8, 1973 · 2.27 years
1901-12-13 → 2038-01-1968 years each way
negative counts: before 1970
UNIX Programmer's Manual, First Edition, time (II), November 3, 1971
The chronological--minded user will note that 2**32 sixtieths of a second is only about 2.5 years.
Every epoch this page reads, on one line
- 1
.NET
0001-01-01· 100 ns ticks - 2
Windows FILETIME
1601-01-01· 100 ns ticks - 3
Excel
1899-12-30· days - 4NTP
1900-01-01· seconds - 5
Mac HFS+
1904-01-01· seconds - 6
Excel 1904
1904-01-01· days - 7Unix
1970-01-01· seconds - 8GPS
1980-01-06· seconds
Is my timestamp in seconds, milliseconds, microseconds or nanoseconds?
Count the digits: a current timestamp has 10 digits in seconds, 13 in milliseconds, 16 in microseconds and 19 in nanoseconds. JavaScript and Java use milliseconds; Unix tools and most APIs use seconds.
The digit count is a strong hint, not proof. NTP, GPS and Mac timestamps are also ten digits today, and a Windows FILETIME and a .NET tick count are both eighteen, which is why this page reads every scale at once and shows the reading it chose next to the others. A FILETIME is also bigger than JavaScript can hold exactly, so the page keeps the digits as you pasted them.
10 digits · 4 scales · the digits alone don't say which
18 digits · 2 scales · only the first digit tells them apart
10 digits of seconds run from 2001-09-09T01:46:40Z to 2286-11-20T17:46:39Z. That is a span of 285 years, not a unit.
How do I convert a Unix timestamp to a date in my time zone?
A Unix timestamp has no time zone: it names one instant everywhere. The date depends on where you read it, so the page shows your own zone and UTC side by side, and any other zone you pick.
The zone picker uses the IANA time zone database, the same one your operating system uses, so daylight saving changes are applied for the date itself, not for today. Going the other way, a date typed without an offset is read as UTC, and the page offers to read it in your own zone instead.
One instant1793057400= 2026-10-26T23:30:00Z
- Los Angeles16:30Mon, Oct 26UTC−07:00
- New York19:30Mon, Oct 26UTC−04:00
- UTC23:30Mon, Oct 26UTC+00:00
- Berlin00:30Tue, Oct 27UTC+01:00
- Kolkata05:00Tue, Oct 27UTC+05:30
- Tokyo08:30Tue, Oct 27UTC+09:00
- Lord Howe10:30Tue, Oct 27UTC+11:00
Berlin, March 29, 202623 hours · the clocks jumped from 02:00 to 03:00
Berlin, October 25, 202625 hours · the clocks went back from 03:00 to 02:00
Central European Standard Time · UTC+01:00Central European Summer Time · UTC+02:00the hour that happened twicethe hour that never happened
What happens to Unix time in 2038?
A Unix time stored as a signed 32-bit integer runs out at 2147483647, which is 2038-01-19 03:14:07 UTC; one second later it wraps to a date in December 1901. Systems that count in 64 bits, as POSIX now requires, are not affected.
The risk in 2026 is storage, not clocks: a MySQL TIMESTAMP column still ends at 2038-01-19 03:14:07 UTC, and so does any file format or embedded device that kept a 32-bit field. NTP has an earlier rollover of its own: its 32-bit seconds wrap in 2036. The page marks any timestamp near or past the 2038 boundary.
2,147,483,647the largest signed 32-bit number
01111111 11111111 11111111 11111111Tue, Jan 19, 203803:14:07 UTC
+ 1 second
-2,147,483,648the same 32 bits, read as a signed number
10000000 00000000 00000000 00000000Fri, Dec 13, 190120:45:52 UTC
Last second, UTC
time_t2038-01-19 03:14:07TIMESTAMP column2038-01-19 03:14:07today2038-01-19
time_t, which POSIX.1-2024 requires, reaches about 292 billion years either side of 1970. Source: POSIX.1-2024 A.4.19, MySQL 8.4, RFC 5905 §6, TN1150Can a Unix timestamp be negative?
Yes: a negative timestamp is a date before 1970. -1 is 1969-12-31 23:59:59 UTC, and -86400 is 1969-12-31 00:00:00 UTC.
POSIX itself leaves negative values undefined, but GNU and most systems treat them as dates before 1970 by documented extension, and so do JavaScript, Python and PostgreSQL. MySQL is the exception: its TIMESTAMP column starts in 1970, and FROM_UNIXTIME(-1) returns NULL. Birth dates and historical records are ordinary negative timestamps, so the page reads them as dates rather than calling them a mistake.
SecondsHow far back (log scale)Date, UTC
0Thu, Jan 1, 197000:00:00 UTC-1Wed, Dec 31, 196923:59:59 UTC-86,400Wed, Dec 31, 196900:00:00 UTC-31,536,000Wed, Jan 1, 196900:00:00 UTC-1,000,000,000Sun, Apr 24, 193822:13:20 UTC-2,147,483,648Fri, Dec 13, 190120:45:52 UTC- POSIX
If the year is <1970 or the value is negative, the relationship is undefined.
GNU date
@-1is 1969-12-31 23:59:59 UTC: negative counts, as an extension to POSIXJavaScriptany date within about 273,790 years of 1970, either way
MySQL TIMESTAMPstarts at 1970-01-01 00:00:01 UTC: it can't hold a negative value
Windows, .NET, Mac, Excel, NTP and GPS: the other epochs
Many systems count from their own zero: Windows from 1601, .NET from the year 1, Mac and HFS+ from 1904, Excel from 1900, NTP from 1900 and GPS from 6 January 1980. A number that makes no sense as a Unix timestamp is often one of these.
The FILETIME 133756272000000000, for example, counts 100-nanosecond intervals since 1601 and is 2024-11-09 12:00:00 UTC. Excel counts days, and treats 1900 as a leap year on purpose, so its serials below 61 are a day off and the page flags them. GPS time skips leap seconds and has run 18 seconds ahead of UTC since 2017.
| Epoch | Counts | Since | On Oct 26, 2026 | Digits | Time zone | Where you meet it |
|---|---|---|---|---|---|---|
| Unix seconds | seconds | 1970-01-01 | 1792972800 | 10 | UTC (POSIX) | date +%s, Python time.time() |
| milliseconds | 1970-01-01 | 1792972800000 | 13 | UTC | JavaScript Date.now(), Java | |
| nanoseconds | 1970-01-01 | 1792972800000000000 | 19 | UTC | Go UnixNano() | |
| 100 ns ticks | 1601-01-01 | 134374464000000000 | 18 | UTC (local time on FAT) | NTFS, Active Directory lastLogon, Win32 | |
| 100 ns ticks | 0001-01-01 | 639285696000000000 | 18 | UTC or local, by Kind | DateTime.Ticks | |
| days | 1899-12-30 | 46321 | 5 | none: a wall clock | Excel, Google Sheets, LibreOffice | |
| days | 1904-01-01 | 44859 | 5 | none: a wall clock | older Excel for Mac | |
| seconds | 1904-01-01 | 3875817600 | 10 | GMT (classic HFS: local) | HFS+ file dates | |
| NTP seconds | seconds | 1900-01-01 | 4001961600 | 10 | UTC | NTP packets |
| GPS seconds | seconds | 1980-01-06 | 1477008018 | 10 | no leap seconds: UTC + 18s | GPS receivers, RINEX files |
Does Unix time count leap seconds?
No. Unix time gives every day exactly 86,400 seconds, so a leap second has no number of its own, and POSIX says so: broken-down POSIX time is not necessarily UTC, despite its appearance.
Since 1972, 27 leap seconds have been added to UTC; Unix time has no number for the extra second, so one timestamp stands for two seconds. The last was on 2016-12-31, and in 2022 the General Conference on Weights and Measures decided that by 2035 the limit that makes them necessary will be raised, which in practice ends them. GPS time, which never had them, shows the difference: it is 18 seconds ahead.
The last seconds of December 31, 1998
Unix time gives 915148800 twice; GPS time, which has no leap seconds, keeps counting.
27 leap secondsnone after December 31, 2016 · none announced before June 28, 2027
before GPS time begansince GPS time began: each one put it a second further ahead
POSIX.1-2024, Rationale A.4.19
Coordinated Universal Time (UTC) includes leap seconds. However, in POSIX time (seconds since the Epoch), leap seconds are ignored (not applied) to provide an easy and compatible method of computing time differences. Broken-down POSIX time is therefore not necessarily UTC, despite its appearance.
Unix timestamps in Python, JavaScript, Java, C#, Go, SQL and the shell
Every language converts both ways in a line or two. The traps are the unit (JavaScript and Java count milliseconds) and the time zone (a database may read the value in its session zone).
Each example below turns 817876800 into a date and a date back into seconds, and each was run to check its output. On the shell, macOS and the BSDs take date -r 817876800 while GNU/Linux takes date -d @817876800: the two are not interchangeable.
from datetime import datetime, timezone t = datetime.fromtimestamp(817876800, tz=timezone.utc) print(t.isoformat()) # 1995-12-02T04:00:00+00:00 back = datetime(1995, 12, 2, 4, 0, tzinfo=timezone.utc) print(int(back.timestamp())) # 817876800
Run with Python 3.14.4 on October 26, 2026: it prints what the comments show.
const t = new Date(817876800 * 1000); // Date counts milliseconds console.log(t.toISOString()); // 1995-12-02T04:00:00.000Z const back = Date.UTC(1995, 11, 2, 4, 0, 0) / 1000; // months count from 0 console.log(back); // 817876800
Run with Node.js 22.23.2 on October 26, 2026: it prints what the comments show.
import java.time.Instant;
public class Main {
public static void main(String[] args) {
Instant t = Instant.ofEpochSecond(817876800L);
System.out.println(t); // 1995-12-02T04:00:00Z
long back = Instant.parse("1995-12-02T04:00:00Z").getEpochSecond();
System.out.println(back); // 817876800
}
}Run with OpenJDK 25.0.2 on October 26, 2026: it prints what the comments show.
var t = DateTimeOffset.FromUnixTimeSeconds(817876800); Console.WriteLine(t.ToString("o")); // 1995-12-02T04:00:00.0000000+00:00 var back = new DateTimeOffset(1995, 12, 2, 4, 0, 0, TimeSpan.Zero).ToUnixTimeSeconds(); Console.WriteLine(back); // 817876800
Run with .NET 10.0.103 on October 26, 2026: it prints what the comments show.
package main import ( "fmt" "time" ) func main() { t := time.Unix(817876800, 0).UTC() fmt.Println(t.Format(time.RFC3339)) // 1995-12-02T04:00:00Z back := time.Date(1995, 12, 2, 4, 0, 0, 0, time.UTC).Unix() fmt.Println(back) // 817876800 }
Run with Go 1.25.5 on October 26, 2026: it prints what the comments show.
SET TIME ZONE 'UTC'; SELECT to_timestamp(817876800); -- 1995-12-02 04:00:00+00 SELECT EXTRACT(EPOCH FROM TIMESTAMPTZ '1995-12-02 04:00:00+00')::bigint; -- 817876800
Run with PostgreSQL 16.10 on October 26, 2026: it prints what the comments show.
SET time_zone = '+00:00'; SELECT FROM_UNIXTIME(817876800); -- 1995-12-02 04:00:00 SELECT UNIX_TIMESTAMP('1995-12-02 04:00:00'); -- 817876800
Run with MySQL 9.5.0 on October 26, 2026: it prints what the comments show.
# macOS and the BSDs: -r takes seconds date -u -r 817876800 '+%F %T' # 1995-12-02 04:00:00 date -u -j -f '%F %T' '1995-12-02 04:00:00' +%s # 817876800 # Linux (GNU coreutils): -d @seconds; GNU's -r reads a file's date date -u -d @817876800 '+%F %T' # 1995-12-02 04:00:00 date -u -d '1995-12-02 04:00:00' +%s # 817876800
Run with the date command of macOS 26.6 and of GNU coreutils 9.12 on October 26, 2026: it prints what the comments show.
Epoch time: questions and answers
What is epoch time?
How do I convert epoch to date, and date to epoch?
new Date(817876800 * 1000) does the first in JavaScript.What is the current epoch time?
date +%s prints it in seconds.Is a Unix timestamp in seconds or milliseconds?
Why does Unix time start in 1970?
Is Unix time the same as UTC?
What is the year 2038 problem?
TIMESTAMP column, for one, still ends at that second.Can I convert a date before 1970?
TIMESTAMP can't hold them, but most languages and databases read them as dates before 1970.How do I convert a Windows FILETIME to a date?
How do I convert an Excel date serial to a timestamp?
Does the converter handle time zones and daylight saving?
Is my timestamp sent anywhere?
Missing something?Suggest a feature or a new tool
Related tools
UUID Generator
Generate UUID v4, v7, v1, v5 and v3 or GUIDs in bulk, in any format, and decode a UUID's version and timestamp
Base64 Decode & Encode
Decode and encode Base64: text (UTF-8, URL-safe), images, PDFs and any file to Base64 or a data URI
Binary Translator
Translate text to binary and binary to text: auto-detect, hex, decimal and octal
Subnet Calculator
Network, broadcast, usable hosts and masks for any IPv4 or IPv6 block, plus VLSM, splits and cloud subnets