Skip to main content
7B BusyBoss

Unix Timestamp Converter: Epoch to Date, Seconds and ms

Unix timestamp converter: paste epoch seconds or milliseconds and get UTC, local time, ISO 8601 and RFC 2822, or turn any date into a timestamp.

No limitsZero data leaksSuper fast

Unix Timestamp Converter

Convert Unix timestamps to readable dates and back. Seconds, milliseconds, microseconds and nanoseconds are detected from the number of digits.

Current Unix time (live)

…

starting clock

Timestamp → Date

Paste a Unix timestamp in seconds, milliseconds, microseconds or nanoseconds.

Enter a timestamp above to see the date, or hit “Now”.

Date → Timestamp

Pick a date & time, then say whether that wall clock is in your local zone (local time) or in UTC.

Pick a date and time to get its Unix timestamp.

Current Unix time in code

How to get the current epoch in each language. Only JavaScript counts in milliseconds by default; everything else returns seconds.

LanguageSecondsMilliseconds
JavaScript
Math.floor(Date.now() / 1000)
Date.now()
Python
import time; int(time.time())
int(time.time() * 1000)
PHP
time()
(int) floor(microtime(true) * 1000)
Java
Instant.now().getEpochSecond()
System.currentTimeMillis()
MySQL
SELECT UNIX_TIMESTAMP();
SELECT FLOOR(UNIX_TIMESTAMP(NOW(3)) * 1000);
PostgreSQL
SELECT FLOOR(EXTRACT(EPOCH FROM NOW()))::bigint;
SELECT FLOOR(EXTRACT(EPOCH FROM NOW()) * 1000)::bigint;
Shell (GNU date)
date +%s
date +%s%3N

Don't take our word for it — turn your wi-fi off.

This tool keeps working with no connection at all, because your file is processed here in the browser. A site that uploads your file cannot do that. Disconnect and try it — this box will notice.

Prefer to check properly? Open DevTools → Network, then run the tool. Your file appears in no request. Why none of our tools upload

You're on 7BusyBoss — 300+ free tools that run instantly in your browser. No signup, nothing uploaded.

Browse all Date Tools →

Need to get the finished file to somebody else? Quick Share sends it straight to their device over a direct connection, so it never sits on a server waiting to be collected.

Open Quick Share →
About this tool

What a Unix timestamp converter does

A Unix timestamp is the number of seconds since 00:00:00 UTC on 1 January 1970. A Unix timestamp converter turns that count into a date, and a date back into the count. 1760000000 is 9 October 2025 at 08:53:20 UTC, which is 14:23:20 in India and 04:53:20 that morning in New York. The number is the same everywhere. Only the clock reading changes with the zone.

Most things you will paste here are 10 or 13 digits long. Ten digits is seconds, the unit Unix tools and nearly every API use. Thirteen is milliseconds, which is what JavaScript's Date.now() returns. The converter reads the digit count, says which unit it assumed, and lets you override it.

Seconds, milliseconds, microseconds or nanoseconds

The digit count settles it for any date between April 1970 and November 2286, and the bands do not overlap.

DigitsUnitSame instant (9 Oct 2025 08:53:20 UTC)Where you meet it
10 or fewerseconds1760000000Unix tools, Python, PHP, MySQL, JWT exp and iat claims, most APIs
11 to 13milliseconds1760000000000JavaScript Date.now(), Java currentTimeMillis(), Kafka, MongoDB
14 to 16microseconds1760000000000000PostgreSQL internals, tracing systems
17 or morenanoseconds1760000000000000000Go time.Now().UnixNano(), Python time.time_ns(), InfluxDB

The two classic mistakes are loud in one direction and quiet in the other. Read the 13-digit 1760000000000 as seconds and you land in the year 57742, which nobody mistakes for real data. Read the 10-digit 1760000000 as milliseconds and you get 21 January 1970 at 08:53:20 UTC, which looks like a plausible bug and takes longer to find. A date of exactly 1 January 1970 00:00:00 almost always means the value was zero or missing.

Convert a Unix timestamp to time: worked example

Paste 1760000000 into the Timestamp to Date box. It has 10 digits, so the tool reads it as seconds and shows:

  • UTC: 2025-10-09 08:53:20
  • ISO 8601: 2025-10-09T08:53:20.000Z (the Z means UTC)
  • RFC 2822: Thu, 09 Oct 2025 08:53:20 +0000 (the format in email headers and RSS feeds)
  • Local time, with your zone name and offset, for example 2025-10-09 14:23:20 in Asia/Kolkata (GMT+5:30)
  • The same instant as 1760000000 seconds and 1760000000000 milliseconds

The ISO and RFC 2822 lines are always in UTC. The local line depends on the zone your browser reports, which is why it carries the zone name.

Convert a date to a Unix timestamp

Pick 15 October 2026 at 09:30 in the Date to Timestamp box. The result depends on which zone that wall clock belongs to, and the "Read as" switch lets you say.

09:30 on 15 Oct 2026, read asSecondsMilliseconds
India (Asia/Kolkata, +05:30)17920368001792036800000
UTC17920566001792056600000
New York (EDT, -04:00)17920710001792071000000

The India and UTC rows differ by 19800 seconds, which is 5.5 hours, the IST offset. If a stored time is off by a whole number of hours, this is nearly always why: a wall clock was read in one zone and displayed in another. Store the timestamp, apply a zone once, where a person reads it. For a wall clock in a third zone, convert it first with the time zone converter.

Round numbers worth recognising

Timestamp (seconds)UTC date and timeWhy it matters
01970-01-01 00:00:00The epoch. Usually a missing value
-864001969-12-31 00:00:00Negative values are dates before 1970 and the tool accepts them
10000000002001-09-09 01:46:40Where seconds timestamps became 10 digits
17000000002023-11-14 22:13:20Common test value
18000000002027-01-15 08:00:00Next round billion-and-a-bit
21474836472038-01-19 03:14:07Largest signed 32-bit value, the year 2038 problem
42949672962106-02-07 06:28:16Where an unsigned 32-bit counter wraps

Current Unix time in code

Each line returns the current epoch. Seconds first, because that is what most systems want. Only JavaScript counts in milliseconds by default. The tool shows the same table with a copy button on every snippet.

LanguageSecondsMilliseconds
JavaScriptMath.floor(Date.now() / 1000)Date.now()
Pythonimport time; int(time.time())int(time.time() * 1000)
PHPtime()(int) floor(microtime(true) * 1000)
JavaInstant.now().getEpochSecond()System.currentTimeMillis()
MySQLSELECT UNIX_TIMESTAMP();SELECT FLOOR(UNIX_TIMESTAMP(NOW(3)) * 1000);
PostgreSQLSELECT FLOOR(EXTRACT(EPOCH FROM NOW()))::bigint;SELECT FLOOR(EXTRACT(EPOCH FROM NOW()) * 1000)::bigint;
Shell (GNU date)date +%sdate +%s%3N

Going the other way, date -d @1760000000 on Linux and date -r 1760000000 on macOS print the date for a timestamp. In Excel, =A1/86400+25569 formatted as a date does the same (1760000000 gives 45939.37).

How to use this converter

  1. The strip at the top is the current Unix time, ticking every second, with copy buttons for seconds and milliseconds.
  2. Timestamp to Date: paste a number. The tool reports the unit it detected and the digit count. Pick a unit from the Unit menu if the guess is wrong. Each output row has its own copy button.
  3. Date to Timestamp: pick a date and time, then choose "Local time" or "UTC" in the Read as menu. You get seconds, milliseconds, the ISO 8601 form in UTC, and the microsecond and nanosecond forms underneath.
  4. The code table at the bottom has copy buttons for the current-epoch snippet in each language.

If the number came out of a token, the JWT decoder shows the exp and iat claims as dates without a round trip through this page. For the gap between two calendar dates, rather than the meaning of one instant, use the date difference calculator.

Common mistakes and limits

  • Unit mix-ups. Dividing a 13-digit value by 1000 before passing it to a seconds API, or multiplying a 10-digit one by 1000 before new Date(), fixes most "wrong by decades" bugs.
  • A zone applied twice. The timestamp has no zone. If a time is wrong by exactly your UTC offset, something parsed a local wall clock as UTC or the other way round.
  • The year 2038. A signed 32-bit counter overflows after 2147483647, at 03:14:07 UTC on 19 January 2038. Anything written recently uses 64-bit values. Old embedded devices and old database schemas are where it still bites.
  • Leap seconds. Unix time ignores them. 27 have been added since 1972, none since 2016, so two timestamps 86400 apart are a calendar day apart even if the physical interval differed by a second.
  • Range. A JavaScript date holds 100,000,000 days either side of the epoch, roughly 271821 BC to 275760 AD. The tool reports anything beyond that as out of range rather than guessing.
  • The local row uses the zone database in your browser and operating system. A machine that missed a rule change shows that zone an hour out.

How to use the Unix Timestamp Converter

Takes about a minute. No signup, no download, your data stays in your browser.

  1. 1
    Open the tool. Scroll up to the Unix Timestamp Converter above — it loads instantly in your browser, no install needed.
  2. 2
    Enter your values. The fields come pre-filled with realistic defaults so you can see how it works — replace them with your own numbers.
  3. 3
    Read the result. The output updates instantly. Copy or share it — nothing is uploaded to a server, everything stays on your device.

Frequently asked questions

Common questions about the Unix Timestamp Converter.

How do I convert a Unix timestamp to a date?

Paste the number into the Timestamp to Date box. 1760000000 is 9 October 2025 at 08:53:20 UTC, shown as 2025-10-09T08:53:20.000Z in ISO 8601 and Thu, 09 Oct 2025 08:53:20 +0000 in RFC 2822. The local row applies your browser zone, so in India the same value reads 14:23:20.

Is my timestamp in seconds or milliseconds?

Count the digits. A seconds timestamp for any current date has 10 digits, a milliseconds one has 13, microseconds 16 and nanoseconds 19. The converter uses those bands automatically and says which unit it assumed. If a 13-digit value is read as seconds you get the year 57742, and a 10-digit value read as milliseconds lands on 21 January 1970.

How do I convert a date to a Unix timestamp?

Pick the date and time in the Date to Timestamp box and choose whether that wall clock is local time or UTC. 15 October 2026 at 09:30 is 1792036800 seconds when read in India and 1792056600 when read as UTC, a difference of 19800 seconds, which is the 5.5-hour IST offset. Multiply by 1000 for milliseconds.

What is the current Unix timestamp?

The strip at the top of the tool shows it live in seconds and milliseconds with copy buttons. In code it is date +%s in a shell, int(time.time()) in Python, time() in PHP, Math.floor(Date.now() / 1000) in JavaScript, and SELECT UNIX_TIMESTAMP(); in MySQL.

Does a Unix timestamp have a time zone?

No. It counts seconds since 1 January 1970 00:00:00 UTC and is the same number everywhere on Earth. A zone enters only when the number is displayed, which is why the tool shows UTC and your local zone side by side. A time that is wrong by exactly your UTC offset means a wall clock was read in the wrong zone somewhere.

How do I get a Unix timestamp with milliseconds?

Multiply the seconds value by 1000, or use a call that returns milliseconds directly: Date.now() in JavaScript, System.currentTimeMillis() in Java, int(time.time() * 1000) in Python, or date +%s%3N with GNU date. The converter prints both units for every result, so 1760000000 seconds shows 1760000000000 milliseconds next to it.

What is the year 2038 problem?

A signed 32-bit integer tops out at 2147483647, which as a seconds timestamp is 03:14:07 UTC on 19 January 2038. Systems that still store time in 32 bits wrap to a negative number at that moment. Modern operating systems, languages and databases use 64-bit counters, so the risk sits in old embedded devices and long-lived schemas.

Why does my timestamp show 1 January 1970?

Because the value was zero, empty or null, and zero is the epoch itself. A date in late January 1970, such as 21 January 1970 for 1760000000, means a seconds value was read as milliseconds instead. Check that the field was populated, then check the unit.

Community rating

Discussion (0)

No comments yet. Start the discussion.