If you've ever debugged an API response, poked at a database, or read a webhook log, you've seen a Unix timestamp — that string of digits like 1756684800 that means nothing to a human but everything to a computer. Converting it to a readable date is one of those small skills that saves you ten minutes every time you touch backend systems.

Here's what that number actually means and how to decode it.

What a Unix Timestamp Is

A Unix timestamp (also called epoch time or POSIX time) counts the number of seconds that have passed since January 1, 1970, 00:00:00 UTC — the Unix epoch. That's the baseline every Unix-based system uses as its "zero." So:

  • 0 = January 1, 1970, 00:00:00 UTC
  • 1756684800 = some date in 2025 (the number of seconds from the epoch to that date)
  • 2147483647 = January 19, 2038 — the famous 32-bit overflow limit

Because it's just a count of seconds, a timestamp is the same everywhere — there are no time zones built in. Time zones only enter when you display the timestamp as a human-readable date.

Seconds vs Milliseconds: The Common Bug

This trips up everyone. JavaScript (and many web APIs) uses milliseconds, not seconds. So in JavaScript, the timestamp 1756684800 is interpreted as January 21, 1970 — because it's treating 1.7 billion as milliseconds. Multiply by 1000 to convert seconds to milliseconds, or divide by 1000 to go the other way. If your converted date lands in 1970, you've almost certainly mixed up seconds and milliseconds.

Why Timestamps Show Up Everywhere

  • APIs and databases: Most backends store and return timestamps because they're timezone-agnostic and sort cleanly.
  • Webhooks and logs: Event logs record when things happened as epoch seconds.
  • File metadata: Operating systems track file creation and modification times as timestamps internally.
  • JWT tokens: JSON Web Tokens carry iat (issued at) and exp (expiration) as Unix timestamps.

Verified Example: Decoding 1756684800

Let's decode a real timestamp to prove the math: 1756684800. The Unix epoch is January 1, 1970, 00:00:00 UTC, and the standard epoch definition used by POSIX systems is documented in IEEE Std 1003.1 (POSIX.1). Divide 1756684800 by 86,400 seconds per day: 1756684800 ÷ 86400 = 20,332 days after the epoch. 20,332 days ÷ 365.2425 days per Gregorian year ≈ 55.67 years after 1970, which lands in late August 2025. The exact UTC date and time depend on the remaining fraction — a timestamp converter computes this precisely. You can verify the year by noting 20,332 days from January 1, 1970 reaches August 31, 2025 (including leap days in 1972, 1976, ... 2024).

Convert Any Timestamp Instantly

Our Unix Timestamp Converter takes a timestamp in seconds (or milliseconds — it detects which) and returns the readable date in both UTC and your local time. Paste in any value from an API, log, or token, and you'll see exactly when it corresponds to — no mental math, no 1970 bugs.