Unix Timestamp Converter

What Is a Unix Timestamp (Epoch Time)?

// Get the current Unix timestamp in JavaScript
const timestampSeconds = Math.floor(Date.now() / 1000);
console.log(timestampSeconds); // → 1741965432

// Milliseconds (native JavaScript)
const timestampMs = Date.now();
console.log(timestampMs); // → 1741965432000

// Convert timestamp back to a Date object
const date = new Date(timestampSeconds * 1000);
console.log(date.toISOString()); // → '2025-03-14T15:37:12.000Z'

// Python equivalent
// import time
// timestamp = int(time.time())  # → 1741965432

Key Features

Unix Timestamp vs Other Date Formats

Conversion Examples

1741965432

2025-03-14T15:37:12Z

946684800

2000-01-01T00:00:00Z

-86400

1969-12-31T00:00:00Z

1741965432000

2025-03-14T15:37:12.000Z

How to Convert Unix Timestamp to Date

1. 1

   Select Conversion Direction

   Choose "Timestamp → Date" to decode a Unix timestamp into a human-readable date, or "Date → Timestamp" to convert a calendar date and time into a Unix timestamp.

2. 2

   Enter Your Value

   Paste or type a Unix timestamp (e.g., 1741965432 or 1741965432000) into the input field. The tool automatically identifies whether it is seconds, milliseconds, or microseconds. For Date → Timestamp, select the year, month, day, hour, minute, and second using the date picker.

3. 3

   Copy the Converted Result

   Instantly see the result in UTC, local time, ISO 8601, and relative time. Click the Copy button next to any format to copy it directly to your clipboard.

Common Use Cases

API Development and Debugging

Decode opaque timestamps in API responses, JWT token payloads (iat, exp, nbf claims), webhook event data, and log entries. Instantly verify whether an authentication token is expired or when an event occurred.

Database Timestamp Storage and Queries

Convert between Unix timestamps and human-readable dates when writing database queries, inspecting stored records, or validating that date range filters are correctly specified in your WHERE clauses.

Log File Analysis and Correlation

Many system and application logs record events as Unix timestamps. Convert suspicious log entries to human-readable times to correlate events across multiple services, identify attack windows, or pinpoint the exact moment an error occurred.

JWT Token Expiration Verification

JSON Web Tokens encode iat (issued at), exp (expires at), and nbf (not before) as Unix timestamps in their payload. Paste these values directly to verify token validity windows without manually doing the epoch math.

Cron Job Scheduling

Verify that cron job schedules, scheduled tasks, and time-based triggers align with the intended execution windows by converting proposed run times to timestamps and back.

Cross-Timezone Date Coordination

Unix timestamps are inherently timezone-neutral. Use this converter to establish a shared reference point when coordinating dates and deadlines across teams in different time zones, confirming the UTC equivalent of any local time.

Technical Reference

Unix Timestamp Definition

A Unix timestamp is the integer count of seconds elapsed since the Unix epoch: January 1, 1970, 00:00:00 UTC (Coordinated Universal Time). The value is the same regardless of the observer's local timezone, making it an ideal timezone-neutral representation for storing and comparing times.

Maximum 32-Bit Signed Integer Value

The maximum value of a signed 32-bit integer is 2,147,483,647. As a Unix timestamp, this corresponds to January 19, 2038 at 03:14:07 UTC. Systems that store timestamps in 32-bit signed integers will overflow at this moment — a problem known as the Year 2038 problem. 64-bit systems can represent dates billions of years into the future.

JavaScript Uses Milliseconds

JavaScript's Date.now() and new Date().getTime() return the number of milliseconds since the epoch — not seconds. This produces 13-digit numbers. To convert to the standard Unix timestamp in seconds, divide by 1000 and floor: Math.floor(Date.now() / 1000). Many APIs and tools expect seconds, so this conversion step is critical.

Negative Timestamps Represent Pre-Epoch Dates

Unix timestamps can be negative to represent dates before January 1, 1970. For example, -86400 represents December 31, 1969 at 00:00:00 UTC. The range of a signed 64-bit timestamp stretches from roughly 292 billion years before the epoch to 292 billion years after, more than enough for any practical application.

Unix Time Does Not Account for Leap Seconds

Unix time assumes exactly 86,400 seconds per day (24 hours × 60 minutes × 60 seconds). In reality, leap seconds are occasionally inserted by IERS to keep UTC synchronized with the Earth's rotation. This means Unix time is not perfectly linear in relation to TAI (International Atomic Time), and the difference grows over time. For most applications, this discrepancy is irrelevant, but precision timekeeping systems must account for it.

Best Practices for Timestamp Handling

Always Store Timestamps in UTC

Store timestamps in UTC (or as Unix timestamps) and convert to local time only at the display layer. Mixing timezones in your database is a common source of bugs that are difficult to reproduce and debug, especially around daylight saving time transitions.

Use Millisecond Precision for Modern APIs

Most modern APIs, JavaScript environments, and databases use milliseconds (13-digit timestamps) rather than seconds (10-digit timestamps). When integrating with external systems, confirm the expected precision — passing a millisecond timestamp where seconds are expected will produce dates roughly 11,000 years in the future.

Beware the Year 2038 Problem

Systems that store Unix timestamps in 32-bit signed integers will overflow on January 19, 2038 at 03:14:07 UTC. Audit legacy systems for 32-bit timestamp fields and migrate to 64-bit integers or ISO 8601 strings. Most modern languages and databases use 64-bit timestamps by default, but embedded systems, older databases, and file systems may still be at risk.

Never Rely on Client-Side Clocks for Security

Client device clocks can be set to any value, accidentally or maliciously. Never use a client-supplied timestamp for security-sensitive logic such as JWT expiration checks, session timeouts, or rate limiting. Always validate timestamps on the server using a trusted time source.

Use ISO 8601 for Human-Readable Interchange

When you need a timestamp format that is both machine-parseable and human-readable — for example, in log files, configuration files, or API responses where a developer might read the output — ISO 8601 (e.g., 2025-03-14T15:37:12Z) is the best choice. It is sortable lexicographically, unambiguous, and supported by virtually all modern parsers.

Frequently Asked Questions