Time Tools

Timestamp Converter

Convert between Unix timestamps and human-readable dates. Supports seconds, milliseconds, and multiple formats.

Your data never leaves your browser — nothing is sent to any server.

Current time
1,780,343,745
Monday, June 1, 2026 — 09:55:45 PM
UTC+02:00
Enter a timestamp or pick a date to convert
How to use
  1. 1

    Enter a timestamp or pick a date

    Type a Unix timestamp on the left or pick a date on the right — both sides sync automatically. The tool auto-detects seconds vs milliseconds.

  2. 2

    Choose seconds or milliseconds

    Use the Seconds/Milliseconds toggle below the timestamp input to switch units. The value converts automatically when you switch.

  3. 3

    Use 'Current time' for now

    The live clock at the top shows the current timestamp ticking in real time. Click 'Use current time' to fill both inputs with the current moment.

  4. 4

    Read the result card

    The result card shows the full date, time, relative time ('3 hours ago'), and all standard formats (ISO 8601, UTC, Local, Unix). Click any value to copy it.

Common errors

Timestamp shows a date in 1970 or looks wrong

You may be entering a milliseconds timestamp but the tool is interpreting it as seconds, or vice versa. Toggle the sec/ms button to switch the unit manually. Seconds timestamps are typically 10 digits; milliseconds timestamps are 13 digits.

Date picker doesn't set seconds

Some browsers hide the seconds selector in datetime-local inputs by default. The tool includes step="1" to enable seconds precision. If your browser still hides it, type the timestamp directly in the numeric input instead.

Local time doesn't match expected timezone

The local time display uses your browser's timezone setting, which is inherited from your operating system. If it seems wrong, check your system clock and timezone configuration. UTC output is always timezone-independent.

FAQ (7)
What is a Unix timestamp?

A Unix timestamp (also called Epoch time or POSIX time) is the number of seconds that have elapsed since January 1, 1970, 00:00:00 UTC — a reference point known as the Unix epoch. It provides a timezone-independent way to represent a specific moment in time as a single integer, making it the de facto standard for storing and transmitting dates in databases, APIs, and log files.

What is the difference between seconds and milliseconds timestamps?

A seconds-based Unix timestamp is a 10-digit integer (e.g. 1716324000), while a milliseconds-based timestamp is a 13-digit integer (e.g. 1716324000000). Most Unix/Linux systems and languages like Python and PHP use seconds by default. JavaScript's Date.now() and Java's System.currentTimeMillis() return milliseconds. This tool auto-detects the unit based on the digit count but also lets you toggle manually.

How does this tool auto-detect seconds vs. milliseconds?

The tool checks whether the numeric value exceeds 1 trillion (1e12). Values above this threshold are treated as milliseconds, since a seconds timestamp of that magnitude would correspond to a date tens of thousands of years in the future. Values at or below 1 trillion are treated as seconds. You can always override this by toggling the unit manually.

What is the Year 2038 problem?

The Year 2038 problem affects systems that store Unix timestamps as a signed 32-bit integer. The maximum value (2,147,483,647) corresponds to January 19, 2038, 03:14:07 UTC. After this moment the integer overflows, wrapping to a large negative number that maps to December 13, 1901. Modern 64-bit systems, JavaScript, and this tool use 64-bit (or floating-point) representations and are not affected — they can handle dates billions of years into the future.

Why does the local time differ from UTC?

UTC (Coordinated Universal Time) is the global reference time with no timezone offset. Your local time is UTC adjusted by your system's timezone setting, including any daylight saving time rules. For example, if you are in UTC+2 (CEST), a UTC time of 14:00 displays as 16:00 local. This tool shows both so you can compare them directly without mental arithmetic.

Can I convert negative timestamps?

Yes. A negative Unix timestamp represents a date before the Unix epoch (January 1, 1970). For example, -86400 corresponds to December 31, 1969. This is commonly used for historical dates in databases and analytics. Enter any negative number and the tool will convert it correctly.

How is the ISO week number calculated?

The ISO 8601 week number follows the ISO standard where weeks start on Monday and the first week of the year is the one containing the first Thursday. This means January 1 can fall in week 52 or 53 of the previous year, and late December dates can fall in week 1 of the next year. The tool uses this standard algorithm, which differs from the US convention where weeks start on Sunday.

Learn more

Unix Timestamp Converter: Decode and Encode Epoch Time

The Unix timestamp — also known as Epoch time, POSIX time, or seconds since the epoch — is the universal language of time in computing. Every second that passes increments a single integer counter that started at zero on January 1, 1970, 00:00:00 UTC. This deceptively simple representation underpins virtually every database, API, log file, and operating system in existence. Our timestamp converter provides instant, bidirectional translation between this numeric format and every human-readable date representation you might need.

Why Unix Timestamps Matter

Timestamps solve a fundamental problem in distributed systems: representing a precise moment in time without ambiguity. Unlike formatted date strings — which vary by locale, timezone, daylight saving rules, and calendar system — a Unix timestamp is a single integer that means exactly the same thing on every machine in the world. When a server in Tokyo writes 1716324000 to a database and a client in New York reads it, both agree on the exact moment it represents. No parsing, no locale negotiation, no timezone conversion bugs.

Seconds vs. Milliseconds: The Two Standards

The original Unix convention counts in seconds, producing compact 10-digit integers that fit comfortably in a 32-bit signed integer (until the Year 2038 overflow). JavaScript, Java, and many modern APIs instead use milliseconds, yielding 13-digit values that provide sub-second precision. This tool handles both: it auto-detects whether your input is in seconds or milliseconds based on its magnitude, and you can override the detection with a single click. Both representations are shown in the output so you can copy whichever format your system requires.

The Year 2038 Problem

Systems storing Unix timestamps as signed 32-bit integers will overflow on January 19, 2038, at 03:14:07 UTC, when the counter reaches 2,147,483,647 and wraps to a negative number representing December 1901. While modern 64-bit operating systems, databases, and languages (including JavaScript, which uses 64-bit floats) are not affected, embedded systems, legacy firmware, and some database schemas still rely on 32-bit storage. Migrating these systems before 2038 is a critical infrastructure task — and verifying timestamp handling with a converter like this is part of that preparation.

ISO 8601: The Human-Readable Standard

ISO 8601 defines the internationally recognized date-time format: 2024-05-22T10:00:00.000Z. The trailing Zdenotes UTC (Zulu time). This format is unambiguous, lexicographically sortable, and widely supported by databases (PostgreSQL's timestamptz), APIs (JSON, GraphQL), and configuration files (YAML, TOML). Every conversion in this tool includes the ISO 8601 representation alongside UTC, local time, and relative time for comprehensive coverage.

Relative Time in Context

Raw timestamps and formatted dates tell you when something happened, but relative time tells you how long ago. A log entry from 1716320400is hard to contextualize at a glance; “3 hours ago” is instantly meaningful. This tool computes relative time dynamically, handling past and future dates, and scaling through seconds, minutes, hours, days, weeks, months, and years. This is the same calculation that powers the “2 hours ago” labels in Git commits, social media posts, and monitoring dashboards.

Calendar Metadata: Weeks, Day Numbers, and More

Beyond standard date formatting, the converter displays the ISO week number, day of the year (1–366), and full day-of-week name. These are essential for scheduling systems (ISO weeks are used in European business planning), analytics (cohort analysis by week), and compliance (financial reporting periods). The ISO week algorithm — where weeks start on Monday and the first week contains the year's first Thursday — is implemented natively without external libraries.

Common Developer Use Cases

Debugging API responses that return timestamps, verifying JWT expiration claims (exp and iat fields), parsing log files with epoch-based timestamps, converting between frontend (milliseconds) and backend (seconds) representations, seeding test databases with realistic dates, calculating durations between events, and validating cache TTLs — these are everyday tasks that a timestamp converter accelerates from mental arithmetic to a single paste-and-read operation.

No Dependencies, No Data Sent

This tool runs entirely in your browser using the native JavaScript Date API. No timestamps are sent to any server, no third-party date libraries are loaded, and no cookies or analytics track your conversions. The live clock uses setInterval for real-time updates, and all formatting uses built-in toISOString(), toUTCString(), and toLocaleString() methods — battle-tested implementations backed by the ICU library in every modern browser engine.