Back to Home
Blog

Unix Timestamp

Convert between Unix timestamps and dates

Current Unix Timestamp

0
12/31/1969, 4:00:00 PM

Timestamp to Date

Date to Timestamp

Quick Reference

Common Timestamps

  • Unix Epoch: 0 (Jan 1, 1970)
  • Year 2000: 946684800
  • Year 2038 Problem: 2147483647
  • Max JS Date: 8640000000000000 ms

Format Examples

  • Seconds: 1609459200
  • Milliseconds: 1609459200000
  • ISO 8601: 2021-01-01T00:00:00.000Z
  • RFC 2822: Fri, 01 Jan 2021

About the Unix Timestamp Converter

A Unix timestamp is just a count of seconds since January 1, 1970 (UTC) — it's how computers, databases, and APIs quietly track time behind the scenes. The problem is that a number like 1752537600 means nothing to a human until you convert it, and doing that math by hand (accounting for time zones, leap years, and whether the value is in seconds or milliseconds) is tedious and error-prone. This tool exists for the moment you're staring at a log file, a JSON payload, or a database row and need to know exactly what date and time that number represents, or the reverse: turning a date you have in mind into the epoch value your code expects.

The page opens with a live current Unix timestamp that ticks upward in real time, so you always have a correct reference value on hand without looking it up elsewhere. Below that, you can paste in any epoch timestamp and it converts instantly to a readable date and time, or go the other direction by entering a date and getting back the corresponding timestamp. It handles both standard second-based timestamps and millisecond-precision values, which matters because JavaScript's Date.now() and many logging systems use milliseconds while Unix cron and most server tools use seconds — mixing the two up is a classic source of off-by-1000x bugs.

Because the conversion runs entirely in your browser, nothing you paste in — timestamps, dates, or anything else — is sent to a server, which makes it safe to use with values pulled from private logs or internal systems. A practical habit: if a timestamp you're converting looks wildly wrong (like landing in the year 1970 or 50000+), you're probably reading a millisecond value as seconds or vice versa — check the digit count first, since ten digits is typically seconds and thirteen digits is typically milliseconds.

How to convert Unix timestamps and epoch time

Convert between Unix epoch timestamps and human-readable dates directly in your browser.

  1. 1

    Check the live timestamp

    View the current Unix timestamp updating live at the top of the page for a quick, always-accurate reference.

  2. 2

    Paste your timestamp

    Enter the epoch value you want to decode into the input field, whether it's in seconds or milliseconds.

  3. 3

    Read the converted date

    The tool instantly displays the corresponding human-readable date and time — no button click or page reload needed.

  4. 4

    Convert a date to epoch

    In the Date to Timestamp panel, set the date and time (read in your local time zone) and click Convert to Timestamp.

  5. 5

    Set the unit and copy the result

    Use the Seconds / Milliseconds buttons to say how your input should be read. The results list the value in both units plus ISO 8601, UTC and local strings, each with a copy button.

Worked examples

Decode a value from an API response

Input
Unix Timestamp: 1767225600, Unit: Seconds
Result
ISO 8601: 2026-01-01T00:00:00.000Z UTC String: Thu, 01 Jan 2026 00:00:00 GMT Unix Timestamp (milliseconds): 1767225600000

The Local String line shows the same instant in your own time zone — in New York that is Wed Dec 31 2025 19:00:00 GMT-0500, which is why a "New Year" timestamp can land on the previous day on your screen.

A JavaScript Date.now() value pasted with the wrong unit

Input
Unix Timestamp: 1700000000000, Unit: Seconds
Result
ISO 8601: +055840-11-08T22:13:20.000Z

A year in the tens of thousands means the number is milliseconds. Click Milliseconds and the same input becomes 2023-11-14T22:13:20.000Z.

Turn a meeting time into a timestamp

Input
Date to Timestamp — Date 2026-03-15, Time 09:30, browser set to Toronto, then Convert to Timestamp
Result
Unix Timestamp (seconds): 1773581400 ISO 8601: 2026-03-15T13:30:00.000Z

The date and time are read in your browser's time zone. Toronto had already switched to daylight time (UTC−4) on 8 March, so 09:30 local is 13:30 UTC.

A date before 1970

Input
Unix Timestamp: -86400, Unit: Seconds
Result
ISO 8601: 1969-12-31T00:00:00.000Z, Relative Time: "56 years ago" (as of 2026)

Negative values count backwards from the epoch; one day is 86,400 seconds.

Tips and common mistakes

  • Count the digits before anything else. Ten digits is seconds for any date between 2001 and 2286; thirteen digits is milliseconds. The page does not guess — the Seconds / Milliseconds buttons decide how your number is read.
  • The input is read as a whole number. Decimals are cut off (1767225600.9 is treated as 1767225600) and anything after the first non-digit character is ignored, so strip quotes or commas copied from JSON or a spreadsheet.
  • ISO 8601 and UTC String are always in UTC. Local String and the date under the live counter use your browser's time zone, so two people comparing Local String results in different cities will see different clock times for the same timestamp.
  • Relative Time is rounded down to the largest whole unit and treats a month as 30 days and a year as 365 days. It is a quick sanity check, not an exact duration — use the Date Calculator for precise day counts.
  • While Live is on, the results panel follows the current second. Typing a timestamp, editing the date or time, clicking Now or clicking Convert to Timestamp all switch Live off so the result holds still for copying; turn Live back on to return to the running clock.

Frequently Asked Questions

What is a Unix timestamp?

A Unix timestamp is the number of seconds (or milliseconds) that have elapsed since January 1, 1970, 00:00:00 UTC — known as the Unix epoch. It's a time zone–independent way to represent a point in time, widely used in programming and databases.

How do I convert a Unix timestamp to a readable date?

Paste your Unix timestamp into the input field and the tool instantly converts it to a human-readable date and time in your local time zone, UTC, and ISO 8601 format. Works with both second-precision and millisecond-precision timestamps.

Why do some timestamps have 10 digits and others 13?

A 10-digit timestamp counts seconds since the Unix epoch (used in most server-side languages). A 13-digit timestamp counts milliseconds (used in JavaScript's Date.now()). The converter does not guess: pick Seconds or Milliseconds under the input, and the results always list both forms.

What is the Year 2038 problem listed in the Quick Reference?

Systems that store Unix time as a signed 32-bit integer can only count up to 2147483647, which is 03:14:07 UTC on 19 January 2038. One second later the value overflows. Modern 64-bit systems and JavaScript are not affected, but older embedded devices and some database columns still are.

Do Unix timestamps include leap seconds?

No. Unix time assumes every day is exactly 86,400 seconds, so leap seconds are not counted. That keeps date arithmetic simple, and it is why converting a timestamp never produces a time like 23:59:60.