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.

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.

How to use this Timestamp calculator

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.
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.
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.
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.
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.
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

What is a Unix timestamp?

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.

What is the difference between Unix seconds and Unix milliseconds?

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.

What is the Unix Epoch and why does it start on 1 January 1970?

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.

What is the Year 2038 problem (Y2K38)?

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.

How do I convert a Unix timestamp to a human-readable 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.

How do I get the current Unix 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.

What is ISO 8601 and how does it relate to Unix timestamps?

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.

Does India use Unix timestamps in databases and APIs?

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.

What is the difference between UTC and Unix timestamp?

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.

Why do some APIs send timestamps as strings instead of integers?

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.

How do I convert a date and time to a Unix timestamp?

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.

What is a Unix timestamp in milliseconds used for?

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.