Home›Converters›Time & Speed›Unix Timestamp Converter

Unix Timestamp Converter

Time & Speed

Convert Unix timestamps to readable dates, ISO 8601, UTC, and local time. Supports seconds and milliseconds. Built for developers and engineers.

Reviewed by the thecalcu.com team · Last updated June 30, 2026

Unix Timestamp
Date & Time Formats

Enter a Unix timestamp above.

Date / Time → Epoch
Quick Reference
Unix Epoch (origin)
1 Jan 1970 00:00:00 UTC
Y2K (Year 2000)
1 Jan 2000 00:00:00 UTC
1 Billion seconds
9 Sep 2001 01:46:40 UTC
Y2K38 (32-bit overflow)
19 Jan 2038 03:14:07 UTC

What is a Timestamp?

A Unix Timestamp Converter translates between Unix epoch time, a large integer counting seconds (or milliseconds) since 1 January 1970 00:00:00 UTC, and human-readable date and time formats. Every major operating system, database, and programming language uses Unix timestamps internally because they are timezone-agnostic, arithmetically simple, and compact to store.

The Unix Epoch itself is a specific moment: midnight at the start of 1 January 1970 in Coordinated Universal Time (UTC). Every second that passes increments the timestamp by one. As of mid-2026, the Unix timestamp is approximately 1,750,000,000 seconds. Millisecond-precision timestamps (multiplied by 1000) are the default in JavaScript's Date.now(), Java's System.currentTimeMillis(), and most modern REST APIs.

Understanding epoch time is essential for debugging API responses, inspecting database records, reading server logs, and working with scheduled tasks or cron jobs. A raw timestamp like 1700000000 is opaque; once converted, it resolves to Fri, 14 Nov 2023 22:13:20 UTC, instantly actionable information.

This converter handles both directions: paste a Unix timestamp to see it as ISO 8601, RFC 2822 (HTTP Date header format), local browser time, and a relative description such as "8 months ago". Or select a date and time to get the corresponding epoch value in both seconds and milliseconds. The URL updates on every change, so any converted timestamp is shareable with a direct link.

For time zone work alongside this tool, the Time Converter covers duration conversions between seconds, minutes, hours, and days. For developers who also need to inspect numeric representations of timestamps, the Number Base Converter converts between decimal, hexadecimal, binary, and octal, useful when reading raw protocol data or memory dumps.

Why Use a Unix Timestamp Converter?

The core problem with Unix timestamps is that they are unreadable to humans without a tool. A value like 1723650600 gives no intuitive sense of when it falls, and a small arithmetic error, dividing a milliseconds timestamp by 1000 twice, for instance, produces a date in 1970 with no obvious error message.

Common developer scenarios this converter resolves quickly:

  • API debugging, a response contains "expires_at": 1750000000; paste it here to confirm whether the token has already expired or is valid for another two years
  • Log analysis, server logs emit epoch timestamps; convert a run of values to check the interval between events or find when an outage began
  • Database inspection, MySQL TIMESTAMP and PostgreSQL TIMESTAMPTZ store UTC integers; seeing them as ISO 8601 strings makes query results immediately interpretable
  • Scheduled task verification, cron jobs and background workers often log their next run time as an epoch value; converting it confirms the schedule is correct before deploying

The "Now ↺" button and URL state mean you can bookmark any timestamp for later reference or share it with a colleague investigating the same log.

Who Should Use This Converter?

Backend developers building APIs that accept or return timestamps need to verify their serialisation logic. Paste the raw response value here to confirm whether the output is in seconds or milliseconds, and whether the date aligns with your expectations before writing a unit test.

Frontend developers working with JavaScript frequently encounter both Date.now() (milliseconds) and UNIX epoch (seconds) in the same codebase. The seconds/milliseconds toggle in this converter makes switching between the two representations instant. For date arithmetic needs beyond format conversion, the Date Difference Calculator computes the exact interval between any two dates.

DevOps engineers and SREs reading server metrics, Prometheus timestamps, or Kubernetes event logs often encounter epoch values in both seconds and nanoseconds. Converting a suspicious timestamp is the fastest way to correlate an alert spike with a deployment event.

Database administrators inspecting raw table data benefit from seeing TIMESTAMP column values as human-readable strings without writing a FROM_UNIXTIME() SQL query each time.

Security engineers auditing JWT tokens, OAuth expiry fields, or TLS certificate validity periods receive timestamps as epoch integers, this converter decodes them in one paste.

What Insights Does the Timestamp Converter Give You?

ISO 8601 (UTC), the canonical machine-readable format (2024-11-14T22:13:20.000Z). This is what APIs, JSON payloads, and database export files expect. The trailing Z confirms the time is in UTC, removing any time zone ambiguity.

RFC 2822 / HTTP Date, the format used in HTTP headers (Date:, Last-Modified:, Expires:). If you are debugging a caching issue or checking a cookie expiry, this is the string the browser and server exchange.

Local (Browser), the equivalent time in your browser's detected time zone, displayed with the IANA zone name (e.g. Asia/Kolkata). This makes it immediately clear what the timestamp means in IST or any other local time.

Relative time, 6 months ago, 3d from now, a human-scale description that quickly answers "is this in the past or future, and by roughly how much?"

Unix seconds / milliseconds, shown together so you can copy the form your target system expects without doing the ×1000 conversion yourself.

The Quick Reference section at the bottom loads notable timestamps (Unix Epoch origin, Y2K38 overflow, Year 2000) directly into the converter so you can explore their structure and verify your own system's behaviour around boundary values.

How to use this Timestamp calculator

  1. Enter a Unix timestamp in the top input field. Paste an integer from an API response, database query, or log file. If you want to start from the current moment, click Now ↺ to populate the field automatically.

  2. Toggle seconds or milliseconds using the Seconds / Milliseconds switch on the top right. JavaScript's Date.now() returns milliseconds; most other languages and Unix commands return seconds. The converter converts the displayed value automatically when you switch units.

  3. Read the date and time in the output panel below, ISO 8601, RFC 2822, local browser time, and relative time appear simultaneously. Click Copy next to any row to copy it to the clipboard.

  4. Convert a date to epoch using the Date / Time → Epoch section. Click the date picker, select a date and time in your local time zone, and the corresponding Unix timestamps in both seconds and milliseconds appear immediately. Copy either value.

  5. Use "Use current epoch value ↑" to pre-fill the date picker with the date equivalent of whatever timestamp is currently in the top input, useful for making small edits to a known timestamp without retyping it.

  6. Load a quick reference value by clicking any timestamp in the Quick Reference section. This sets the top input to that epoch value so you can inspect notable boundary dates, verify your system handles the Unix Epoch correctly, or check how your code behaves near the Y2K38 overflow.

Formula & Methodology

### Epoch → Date

The converter passes the raw integer to JavaScript's Date constructor after normalising to milliseconds:

Date object = new Date(unix_seconds × 1000) Date object = new Date(unix_milliseconds)         // already ms

From the Date object, the output formats are derived:

- ISO 8601: date.toISOString() → YYYY-MM-DDTHH:mm:ss.sssZ
- RFC 2822: date.toUTCString() → Www, DD Mmm YYYY HH:mm:ss GMT
- Local: date.toLocaleString('en-IN', { timeZone: browserTZ }) → locale-formatted string with IANA zone appended
- Relative: difference from Date.now() divided by progressively larger units (seconds → minutes → hours → days → months → years)

### Date → Epoch

The HTML datetime-local input returns a local time string (YYYY-MM-DDTHH:mm). JavaScript's new Date(string) parses this as local time:

epoch_ms = new Date(datetimeLocalString).getTime() epoch_s  = Math.floor(epoch_ms / 1000)

Note: The datetime picker uses the browser's local time zone. If you need to convert a UTC date to epoch, add Z to the string before parsing: new Date('2024-01-15T10:30:00Z').getTime().

### Notable reference values

| Description | Unix (seconds) | ISO 8601 (UTC) |
|---|---|---|
| Unix Epoch | 0 | 1970-01-01T00:00:00.000Z |
| Y2K | 946684800 | 2000-01-01T00:00:00.000Z |
| Y2K38 (32-bit max) | 2147483647 | 2038-01-19T03:14:07.000Z |
| 1 billion seconds | 1000000000 | 2001-09-09T01:46:40.000Z |
| 2 billion seconds | 2000000000 | 2033-05-18T03:33:20.000Z |

The converter accepts any integer in the range supported by JavaScript's Date object (approximately ±8,640,000,000,000,000 milliseconds from the Epoch, covering ±275,760 years).

Frequently Asked Questions

A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have elapsed since 00:00:00 UTC on 1 January 1970, known as the Unix Epoch. It is a single integer that unambiguously represents any point in time, regardless of time zone or locale. Negative values represent moments before the Epoch, allowing the system to express historical dates as well.
Unix timestamps in seconds count elapsed seconds since the Epoch, for example, 1700000000 represents November 2023. Millisecond timestamps multiply that value by 1000 and are widely used in JavaScript (Date.now()), Java (System.currentTimeMillis()), and modern REST APIs because they provide sub-second precision. When you receive a large number like 1700000000000, it is almost certainly milliseconds; you can divide by 1000 to get the seconds form.
The Unix Epoch is 1 January 1970, 00:00:00 Coordinated Universal Time (UTC). This date was chosen by the early Unix developers at Bell Labs as a convenient, recent reference point that fits within the 32-bit signed integer range available on the hardware of the time. It has since become the standard reference for time representation across virtually all operating systems, programming languages, and network protocols.
The Year 2038 problem occurs on 19 January 2038 at 03:14:07 UTC, when 32-bit signed integers storing Unix timestamps overflow from their maximum value (2,147,483,647) to a large negative number, causing systems to misread the time as 13 December 1901. Modern 64-bit systems are not affected because they can hold timestamps for billions of years into the future. However, legacy embedded systems, older databases, and some firmware still store timestamps in 32-bit fields and require upgrades before this date.
The simplest method is to use this Unix Timestamp Converter, paste your epoch value into the input field and see the date in ISO 8601, UTC, and your local time zone instantly. Programmatically, in JavaScript you use new Date(timestamp * 1000).toISOString() for seconds, or new Date(timestamp).toISOString() for milliseconds. In Python, datetime.utcfromtimestamp(timestamp) returns a datetime object from a seconds-based timestamp.
In this converter, click the 'Now ↺' button to populate the field with the current timestamp. Programmatically: JavaScript uses Math.floor(Date.now() / 1000) for seconds or Date.now() for milliseconds; Python uses import time; int(time.time()); Linux/macOS terminal uses the date +%s command; PHP uses time(). All of these return the number of seconds since 1 January 1970 UTC.
ISO 8601 is the international standard for representing dates and times in a human-readable string format, typically written as YYYY-MM-DDTHH:mm:ss.sssZ where the trailing Z denotes UTC. It is the format returned by JavaScript's Date.prototype.toISOString() and is widely used in JSON payloads, REST APIs, and log files. A Unix timestamp can be converted to ISO 8601 by treating it as seconds since the Epoch and formatting the resulting UTC date, this converter does that automatically.
Yes, Unix timestamps are timezone-agnostic and are the standard choice for timestamp storage in databases (MySQL TIMESTAMP columns, PostgreSQL TIMESTAMPTZ, MongoDB Date objects) and APIs used by Indian companies and globally. The IST (Indian Standard Time, UTC+5:30) offset is only applied at the display layer; the stored value is always UTC-based. This means two servers in different time zones will always agree on the raw timestamp value, eliminating IST/UTC conversion bugs.
UTC (Coordinated Universal Time) is a human-readable time standard with hours, minutes, and seconds, maintained by atomic clocks. A Unix timestamp is a machine-readable integer derived from UTC, specifically, the count of non-leap seconds since 1970-01-01 00:00:00 UTC. UTC has the concept of leap seconds (which Unix time ignores), so technically they diverge by a small number of seconds over decades, but for practical software purposes they are treated as equivalent.
Some APIs use ISO 8601 strings ('2024-01-15T10:30:00Z') rather than integer timestamps for human readability and to avoid ambiguity between seconds and milliseconds. Others use integers for compactness and easy arithmetic. JavaScript's JSON.stringify() serialises Date objects as ISO strings, while most other languages emit integers. When consuming third-party APIs, always check the documentation to determine the format and unit, this converter lets you quickly decode either form.
Use the 'Date / Time → Epoch' section of this converter: select the date and time using the date picker and the corresponding Unix timestamp in both seconds and milliseconds appears instantly. Programmatically, in JavaScript: Math.floor(new Date('2024-01-15T10:30:00Z').getTime() / 1000); in Python: int(datetime(2024, 1, 15, 10, 30, 0, tzinfo=timezone.utc).timestamp()). Always specify the time zone explicitly to avoid local-time ambiguity.
Millisecond timestamps are the default in JavaScript environments (Date.now(), performance.now() for sub-millisecond intervals), Java, and most modern REST APIs because they allow sub-second precision without using decimal numbers. They are essential for measuring durations between events, ordering log entries that occur within the same second, and animation or real-time systems where 1-second granularity is too coarse. This converter's reference table shows both forms so you can work with whichever your system requires.
Also known as
unix timestamp to dateepoch time convertertimestamp to human readabledate to unix timestampepoch to dateunix time converterconvert timestamp to dateepoch converterunix epoch to readable date