Developer

Unix Timestamp Converter

Convert any Unix epoch number into a date, or any date into an epoch. Handles both seconds and milliseconds, shows ISO 8601, UTC, local, and relative formats, and ships with a live now-clock plus quick references for start-of-day, week, month, and year.

Now (seconds)

1777392432

Now (milliseconds)

1777392432920

Now (ISO 8601)

2026-04-28T16:07:12.920Z

Unix timestamp

Unit

Quick references

Click any value to load it as the current timestamp.

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 January 1, 1970 — the so-called Unix epoch. It's the standard way computers store moments in time because it's a single integer that's timezone-agnostic and easy to compare. You'll see timestamps in API responses, database records, log files, JWT claims, cookie expiries, and anywhere two systems need to agree on when something happened. The format comes in two flavors: seconds (10 digits for any current date) and milliseconds (13 digits, used by JavaScript and many web APIs). This tool handles both, runs entirely in your browser, and shows the result in every common format at once.

How to use the timestamp converter

1
Pick a direction
Choose Epoch → Date if you have a number you want to read as a date, or Date → Epoch if you want to convert a calendar moment into an integer.
2
Paste or type the input
For epochs, paste any 10-digit (seconds) or 13-digit (milliseconds) number — auto-detect handles both. For dates, use the picker or type in YYYY-MM-DDTHH:MM:SS format.
3
Read every format at once
Outputs include ISO 8601, UTC string, local time, relative ("in 3 hours"), and both seconds and milliseconds. Click copy on any row to grab it.
4
Use quick references
Click any of the reference buttons (Now, Start of today, Unix epoch, Y2038 limit, etc.) to load that timestamp into the input.

How epoch time works

Unix timestamp = seconds since 1970-01-01 00:00:00 UTC
 
Examples:
  0           → 1970-01-01 (the epoch itself)
  1000000000  → 2001-09-09 (one billion seconds)
  1700000000  → 2023-11-14
  2147483647  → 2038-01-19 (signed 32-bit limit)
 
Conversion:
  ms_timestamp   = sec_timestamp × 1000
  date_object_ms = epoch_value > 1e12 ? epoch_value : epoch_value × 1000
  date           = new Date(date_object_ms)

Epoch time is timezone-neutral — the same integer means the same moment everywhere on earth. To turn it into something a human can read, you apply a timezone offset. ISO 8601 (`2024-01-15T12:34:56Z`) keeps it in UTC; the local format applies your browser's offset. JavaScript stores timestamps in milliseconds, while Unix shells, database fields, and most APIs use seconds — that's why this tool detects the unit by checking whether the value is above 10¹² (a moment well beyond the year 5000 if interpreted as seconds, but plausible if interpreted as milliseconds).

Reference: POSIX.1-2017 §4.16 — Seconds Since the Epoch

Examples

Input	Output
1700000000 (seconds)	2023-11-14T22:13:20Z Standard 10-digit epoch — auto-detected as seconds.
1700000000000 (milliseconds)	2023-11-14T22:13:20Z 13-digit value — auto-detected as milliseconds, same moment.
0	1970-01-01T00:00:00Z The Unix epoch itself.
2024-01-15 12:00 local → epoch	Depends on your timezone offset Date → Epoch always interprets the input in your local timezone.

Common use cases

Read the exp or iat claim from a JWT to see when a token was issued or expires
Convert a Unix timestamp from a server log into a readable date
Find the epoch for a specific moment when calling an API that requires it
Debug why two systems disagree on event ordering — usually a seconds vs milliseconds mix-up
Check how far away the year-2038 problem is for a 32-bit timestamp field
Generate a fixed reference epoch for a database seed or test fixture
Decode a cookie expiry to see whether it lasts a day or a decade
Look up the start-of-day, week, month, or year as an epoch for a query filter

Related tools

JSON Formatter

Format, validate, and minify JSON with precise error line and column reporting.

Base64 Encoder

Encode and decode Base64 text with optional URL-safe variant and UTF-8 support.

JWT Decoder

Split JSON Web Tokens into header, payload, and claims with readable expiry dates.

Age Calculator

Calculate your exact age in years, months, and days from any date of birth.

Frequently asked questions

Why are some timestamps 10 digits and others 13?

10-digit timestamps are in seconds since 1970 — the Unix convention used by C, POSIX, most databases, and shell tools like `date +%s`. 13-digit timestamps are in milliseconds — the format JavaScript's `Date.now()` returns and the format most web APIs accept. They represent the same moments, just with different precision. This tool auto-detects by checking whether the value is above 10¹².

How does auto-detect decide between seconds and milliseconds?

If the absolute value is at least 10¹² (a trillion), the input is treated as milliseconds; otherwise it's treated as seconds. That threshold was chosen because 10¹² seconds since 1970 lands in the year 33,658, which is implausibly far in the future, but 10¹² milliseconds is just 2001. If the heuristic guesses wrong for your case, switch the unit dropdown to Seconds or Milliseconds explicitly.

Are timestamps in UTC or local time?

Unix timestamps are always in UTC by definition — the same integer means the same instant on every machine. What changes is how you display it. The ISO 8601 and UTC outputs use UTC, while the Local time output applies your browser's timezone offset. When you go from a calendar date to an epoch, the input is interpreted in your local timezone.

What's the year-2038 problem?

Older systems store Unix time in a signed 32-bit integer, which maxes out at 2,147,483,647 — the moment 2038-01-19 03:14:07 UTC. After that, the counter rolls over to a large negative number and dates appear to jump back to 1901. Modern systems (and JavaScript's Number) use 64-bit math, so this isn't a concern for most code, but firmware, embedded systems, and old database columns may still need migration.

Why does my date input give a different epoch than I expected?

Almost always it's a timezone issue. The date picker treats your input as local time, so 2024-01-15 12:00 in New York gives a different epoch than 2024-01-15 12:00 in Tokyo. If you need to enter a UTC moment exactly, use the Epoch → Date direction or convert your local time mentally before entering it.

Can I convert a date string like "Jan 15, 2024" directly?

Not in the input field — it expects the datetime-local format (YYYY-MM-DDTHH:MM:SS). For loose date string parsing, use the browser console: `new Date('Jan 15, 2024').getTime()`. Or convert manually using the date picker, which gives you the same calendar moment in a normalized format.

Does this support negative timestamps (before 1970)?

Yes. Negative epoch values represent dates before the Unix epoch — `-86400` is 1969-12-31, for example. This is sometimes used for historical data. Most APIs reject negative timestamps, so double-check before sending one to a third-party service.

Is anything sent to a server?

Nothing. All conversions happen in your browser using the standard `Date` and `Intl.DateTimeFormat` APIs. The live now-clock simply reads `Date.now()` once a second from your local machine. Close the tab and the input is gone.

Last updated 2026-04-24

What is a Unix timestamp?

How to use the timestamp converter

Pick a direction

Choose Epoch → Date if you have a number you want to read as a date, or Date → Epoch if you want to convert a calendar moment into an integer.

Paste or type the input

For epochs, paste any 10-digit (seconds) or 13-digit (milliseconds) number — auto-detect handles both. For dates, use the picker or type in YYYY-MM-DDTHH:MM:SS format.

Read every format at once

Outputs include ISO 8601, UTC string, local time, relative ("in 3 hours"), and both seconds and milliseconds. Click copy on any row to grab it.

Use quick references

Click any of the reference buttons (Now, Start of today, Unix epoch, Y2038 limit, etc.) to load that timestamp into the input.

How epoch time works

Unix timestamp = seconds since 1970-01-01 00:00:00 UTC
 
Examples:
  0           → 1970-01-01 (the epoch itself)
  1000000000  → 2001-09-09 (one billion seconds)
  1700000000  → 2023-11-14
  2147483647  → 2038-01-19 (signed 32-bit limit)
 
Conversion:
  ms_timestamp   = sec_timestamp × 1000
  date_object_ms = epoch_value > 1e12 ? epoch_value : epoch_value × 1000
  date           = new Date(date_object_ms)

Examples

Input	Output
1700000000 (seconds)	2023-11-14T22:13:20Z Standard 10-digit epoch — auto-detected as seconds.
1700000000000 (milliseconds)	2023-11-14T22:13:20Z 13-digit value — auto-detected as milliseconds, same moment.
0	1970-01-01T00:00:00Z The Unix epoch itself.
2024-01-15 12:00 local → epoch	Depends on your timezone offset Date → Epoch always interprets the input in your local timezone.

Common use cases

Read the exp or iat claim from a JWT to see when a token was issued or expires

Convert a Unix timestamp from a server log into a readable date

Find the epoch for a specific moment when calling an API that requires it

Debug why two systems disagree on event ordering — usually a seconds vs milliseconds mix-up

Check how far away the year-2038 problem is for a 32-bit timestamp field

Generate a fixed reference epoch for a database seed or test fixture

Decode a cookie expiry to see whether it lasts a day or a decade

Look up the start-of-day, week, month, or year as an epoch for a query filter