Skip to content
unixframe.com

Epoch time, framed

Unix Timestamp Converter

A precise epoch converter for developers: paste a unix timestamp in seconds or milliseconds and read it back as UTC, local time and ISO 8601 — or go the other way and turn any date into epoch time.

The unit is detected for you, every output value copies in one click, and the current unix time keeps ticking below. No accounts, no limits.

Current Unix Timestamp

——————————

seconds

————————————— ms

01 / Timestamp → Date

waiting for a value

Paste a Unix timestamp to convert it. Seconds, milliseconds, microseconds and nanoseconds all work — the unit is detected from the digit count.

Waiting for a valid timestamp — the date in UTC, your local time and ISO 8601 appear here.

02 / Date → Timestamp

Read the entered time as

pick a date and time

Waiting for a complete date — unix seconds, milliseconds, UTC and ISO 8601 appear here.

What is a Unix timestamp?

A Unix timestamp — also called epoch time — is the number of seconds that have passed since 00:00:00 UTC on 1 January 1970. That moment is the Unix epoch. Because it is a single integer carrying no timezone, no locale and no formatting, it is the cheapest way for a machine to name an exact instant.

Timestamps are stored in UTC so that logs, APIs and databases stay comparable across servers and time zones. The number itself is neutral; turning it into something a person reads — local time, daylight saving, an ISO 8601 string — happens at the edge, which is what this page does for you.

The panel above converts in both directions at once. If you only need one, the timestamp to date converter and the date to timestamp converter each do a single job with more output formats, the current unix timestamp ticks on its own page, and the Discord timestamp generator turns an instant into a tag that renders in each reader’s own zone.

Seconds vs milliseconds

This is where most timestamp confusion starts. C, Python, Go, PostgreSQL and most Unix tooling count whole seconds, so a current timestamp is 10 digits. JavaScript, Java and many logging pipelines count milliseconds, so the same instant is 13 digits.

Read a millisecond value as seconds and your date lands tens of thousands of years in the future. Read seconds as milliseconds and you get 1970. The converter checks the digit count before converting and labels the unit it detected, so you can paste either one without thinking about it.

Microseconds and nanoseconds are handled the same way. A present-day timestamp is 10 digits in seconds, 13 in milliseconds, 16 in microseconds and 19 in nanoseconds, so the timestamp to date converter reads all four and tells you which it used — useful when a value comes out of a Go service or a tracing pipeline rather than a database.

How many seconds in a day, week or year?

Because Unix time counts a flat 86,400 seconds per day, these figures are exact arithmetic rather than calendar approximations — useful when you need to add an offset to a timestamp by hand.

Common durations expressed in Unix seconds
DurationSeconds
1 minute60
1 hour3,600
1 day86,400
1 week604,800
30 days2,592,000
365 days31,536,000
366 days (leap year)31,622,400
Average Gregorian year (365.2425 days)31,556,952

There is deliberately no row for “1 month”: calendar months run from 28 to 31 days, so any single figure for one would be wrong most of the time. Add months with a date library or with the date to timestamp converter instead of multiplying seconds.

Notable Unix timestamps

A few reference points worth recognising when a value looks wrong at a glance.

Landmark Unix timestamp values and the instants they name
TimestampInstant (UTC)
01 Jan 1970, 00:00:00 — the Unix epoch
1,000,000,0009 Sep 2001, 01:46:40
1,234,567,89013 Feb 2009, 23:31:30
2,000,000,00018 May 2033, 03:33:20
2,147,483,64719 Jan 2038, 03:14:07 — signed 32-bit limit
4,294,967,2957 Feb 2106, 06:28:15 — unsigned 32-bit limit

Negative values are valid and describe instants before 1970: −86,400 is 31 December 1969. You can check any of these in the timestamp to date converter.

The year 2038 problem

Systems that store Unix time in a signed 32-bit integer can count no higher than 2147483647 seconds, which is 19 January 2038 at 03:14:07 UTC. One second later the value overflows and wraps to a negative number, reading as December 1901.

The fix is a 64-bit time field, which most current systems already use. Embedded devices, old file formats and database columns typed as a 32-bit integer are where it still bites. This converter uses 64-bit floating point numbers, so you can convert a timestamp past the 2038 limit and get the correct date back.

Other tools

Dedicated pages when you need one direction, one answer, or one format.

Frequently asked questions

What is the Unix epoch?

The Unix epoch is midnight UTC on 1 January 1970, the reference point every Unix timestamp counts from. A timestamp of 0 is that instant, 1000000000 is 9 September 2001, and negative values are valid — they describe dates before 1970.

How do I convert between milliseconds and seconds?

Divide milliseconds by 1000 to get seconds, and multiply by 1000 to go back. In practice you rarely need to do it by hand: current values in seconds are 10 digits and milliseconds are 13, so the converter above reads the digit count, tells you which unit it detected, and gives you both.

Why does my timestamp convert to the wrong date?

There are three usual causes. A date in 1970 means a millisecond value was read as seconds; a date tens of thousands of years out means the opposite; and a date that is off by a few hours is a timezone difference rather than a bad timestamp. Compare the UTC row with the local row above to tell which one you have.

Is epoch time the same as Unix time?

Yes. Unix time, epoch time, POSIX time and “seconds since 1970” all name the same number, which is why an epoch converter and a unix time converter do the same job. Only the counting unit differs between systems.

Does this converter handle the year 2038 problem?

It does. The 2038 limit comes from storing seconds in a signed 32-bit integer, which overflows at 2147483647 — 19 January 2038 at 03:14:07 UTC. This page holds timestamps in 64-bit floating point numbers, so values past that point convert normally. Your own systems still need 64-bit time fields.

Do Unix timestamps count leap seconds?

No. Unix time defines every day as exactly 86400 seconds, so an inserted leap second is skipped rather than counted. That keeps date arithmetic simple, and it is why Unix time can sit a handful of seconds away from astronomical time.

Is anything I paste sent to a server?

No. Every conversion runs in your browser. Nothing you type is logged, stored or transmitted, which also means the converter keeps working offline once the page has loaded.