💻 Date & Time

Unix Timestamp Converter

Convert Unix timestamps to human-readable dates and back. Supports seconds, milliseconds and microseconds. Shows ISO 8601, RFC 2822 and relative time (“3 days ago”). Live ticker shows the current epoch time.

Epoch to date & back ms & microsecond support ISO 8601, RFC 2822, relative UTC + local timezone
AdSense — 728×90 Leaderboard

Unix Timestamp Converter Tool

Current Unix timestamp (seconds)
-
Milliseconds
-
UTC / GMT
Your local time
ISO 8601
RFC 2822
Unix (seconds)
Unix (milliseconds)

Common timezones

New York (ET)
London (GMT/BST)
Dubai (GST)
Mumbai (IST)
Singapore (SGT)
Tokyo (JST)
Sydney (AEST)
Los Angeles (PT)
Berlin (CET/CEST)
Unix timestamp (seconds)
Milliseconds
Microseconds
ISO 8601
AdSense — 728×90 Leaderboard
📅
Need days between two dates?
The Date Difference Calculator finds exact days, weeks and months between any two dates — with business day counting and multiple output formats.
Date Difference →
⭐ Ratings

Rate this tool

4.8
★★★★★
Based on 28,419 ratings
5
25,008
4
1,989
3
853
2
284
1
285
Was this timestamp converter helpful?
Thank you!
Features

Relative time, ms/us support, 9 timezone display — what most epoch tools skip

Most Unix timestamp converters show a UTC date and nothing else. This tool adds relative time output, millisecond and microsecond input, ISO 8601 and RFC 2822 formats, 9 city timezone display, and a live ticker — all on one page.

Relative time output
Every converted timestamp shows how long ago or how far in the future it is — “3 days ago”, “in 2 weeks”, “just now”. Absent from most free epoch converters and the feature developers reach for first.
Seconds, ms and microseconds
Select the unit before converting. JavaScript timestamps are milliseconds; Python and most Unix tools use seconds; some high-precision systems use microseconds. The tool handles all three without any manual division.
Four format outputs at once
UTC, local time, ISO 8601 (used in APIs and databases) and RFC 2822 (used in email headers and HTTP) — all shown simultaneously with individual copy buttons. No need to format the output yourself.
9-city timezone grid
New York, London, Dubai, Mumbai, Singapore, Tokyo, Sydney, Los Angeles and Berlin are shown for every converted timestamp — covering the most common developer and business timezones globally.
Live epoch ticker
The header bar shows the current Unix timestamp in seconds and milliseconds, updating every second. Copy the current timestamp with one click — useful when you need “now” as a timestamp for a database query or API call.
Date to timestamp
The reverse tab converts any human date and time to Unix timestamp in seconds, milliseconds and microseconds — with UTC or local time interpretation. Returns ISO 8601 format too for API use.
How to use

How to convert a Unix timestamp

1
Paste your timestamp
Paste or type the Unix timestamp into the input field on the Timestamp → Date tab. If you are not sure whether it is seconds or milliseconds, check the digit count — 10 digits is seconds (e.g. 1713000000), 13 digits is milliseconds (e.g. 1713000000000).
2
Select the correct unit
Choose Seconds, Milliseconds or Microseconds from the unit dropdown. JavaScript’s Date.now() and performance.now() return milliseconds. Python’s time.time() returns seconds. PostgreSQL and MySQL NOW() are typically seconds. Unix system calls use microseconds for high precision.
3
Read the results
The relative time chip shows at a glance how old the timestamp is. Below it: UTC, local time, ISO 8601, RFC 2822 and the raw second and millisecond values — each with a one-click copy button. The timezone grid shows the same moment across 9 major cities.
4
Convert a date to timestamp
Switch to the Date → Timestamp tab. Enter a date and time, choose whether to treat it as UTC or your local timezone, and click Convert. The result shows Unix seconds, milliseconds and microseconds — plus ISO 8601 format for direct use in APIs and databases.
Comparison

LazyTools vs other Unix timestamp converters

Most free epoch converters show UTC output only. Relative time, multiple formats simultaneously and multi-timezone display together are absent from the major free tools.

Feature⭐ LazyTools epochconverter.comunixtimestamp.comtimestampconvert.com
Timestamp to UTC date
Millisecond input support⚠ Manual
Microsecond input support
Relative time (“3 days ago”)
ISO 8601 output⚠ Partial
RFC 2822 output
Multi-timezone display✔ 9 cities
Live epoch ticker
No ads / no signup⚠ Ads⚠ Ads⚠ Ads
Quick reference

Notable Unix timestamps

Timestamp (s)Date (UTC)Significance
01 Jan 1970 00:00:00Unix epoch origin — the reference point for all timestamps
10000000009 Sep 2001 01:46:40One billion seconds since epoch — celebrated by developers
123456789013 Feb 2009 23:31:30Timestamp with all unique digits — a popular milestone
150000000014 Jul 2017 02:40:001.5 billion seconds since epoch
170000000014 Nov 2023 22:13:201.7 billion seconds since epoch
200000000018 May 2033 03:33:20Two billion seconds since epoch — upcoming milestone
214748364719 Jan 2038 03:14:07Maximum 32-bit signed integer — the Year 2038 problem
42949672957 Feb 2106 06:28:15Maximum 32-bit unsigned integer timestamp

Timestamp units at a glance

UnitDigits (approx.)Example (April 2026)Common use
Seconds (s)101744000000Unix, Python time.time(), PostgreSQL, MySQL
Milliseconds (ms)131744000000000JavaScript Date.now(), Java System.currentTimeMillis()
Microseconds (us)161744000000000000C/C++ gettimeofday(), high-precision logging
Nanoseconds (ns)191744000000000000000Rust Instant, Go time.Now().UnixNano()
Complete guide

Unix Timestamp Converter — Epoch Time Explained for Developers

A Unix timestamp is the number of seconds that have elapsed since 00:00:00 UTC on 1 January 1970 — a reference point known as the Unix epoch. It is the most widely used method for storing and transmitting date and time information in software systems, precisely because it is timezone-independent, format-independent and trivially comparable. Two timestamps can be subtracted to find a duration; one can be compared to another with a simple greater-than check; and any programming language can convert one to a human-readable date in a single function call.

Unix timestamp to date converter online free

Converting a Unix timestamp to a human-readable date requires dividing by the appropriate unit (timestamps are often stored in milliseconds rather than seconds in JavaScript and Java), then constructing a date object. The resulting date is in UTC by default — converting to a local or specific timezone requires knowing the UTC offset for that zone at that point in time, which varies due to daylight saving time. This tool handles all of that automatically and shows the result in nine major timezones simultaneously.

Epoch milliseconds to datetime converter

The most common source of confusion when working with Unix timestamps is the unit. JavaScript’s Date.now() and new Date().getTime() both return milliseconds. Python’s time.time() returns seconds as a float. PostgreSQL’s EXTRACT(EPOCH FROM NOW()) returns seconds. MySQL’s UNIX_TIMESTAMP() returns seconds. Java’s System.currentTimeMillis() returns milliseconds. A 13-digit number is almost certainly milliseconds; a 10-digit number is almost certainly seconds. Converting milliseconds to a date without dividing by 1000 first produces a date in 2526 rather than 2026 — a common debugging puzzle.

Current Unix timestamp with timezone

The live ticker in this tool shows the current Unix timestamp in both seconds and milliseconds, updating every second. This is useful when you need to copy the current time as a timestamp for use in a database query, an API call body, a log entry or a debugging session. The ticker value is equivalent to running Date.now() in a browser console or int(time.time()) in a Python shell.

ISO 8601 date format converter

ISO 8601 is the international standard for date and time representation, widely used in APIs, databases and data interchange formats. The format is YYYY-MM-DDTHH:MM:SSZ (the Z indicates UTC) or YYYY-MM-DDTHH:MM:SS+HH:MM for a specific timezone offset. ISO 8601 is the format returned by JavaScript’s new Date().toISOString(), Python’s datetime.utcnow().isoformat() and most REST APIs. This tool shows the ISO 8601 representation of any converted timestamp so it can be pasted directly into API requests or database inserts.

The Year 2038 problem

The Unix timestamp 2147483647 — equivalent to 19 January 2038 at 03:14:07 UTC — is the maximum value representable by a 32-bit signed integer. Systems that store timestamps as 32-bit signed integers will overflow on this date, wrapping to a large negative number and typically displaying a date in 1901. This is analogous to the Year 2000 bug. Modern systems use 64-bit integers which extend the representable range to the year 292 billion CE — well beyond any practical concern. The solution for legacy systems is to migrate timestamp storage from INT(11) to BIGINT in databases, and from int32_t to int64_t or time_t in C/C++ code.

Python datetime from timestamp

In Python, converting a Unix timestamp to a datetime object uses datetime.fromtimestamp(ts) for local time or datetime.utcfromtimestamp(ts) for UTC. Converting a datetime to a Unix timestamp uses datetime.timestamp() in Python 3.3+ or calendar.timegm(dt.timetuple()) for UTC datetimes in older versions. The arrow and pendulum libraries provide more ergonomic timezone-aware datetime handling and are preferred in production code over the standard library datetime module for complex timezone work.

Frequently asked questions

A Unix timestamp is the number of seconds (or milliseconds, depending on the system) that have elapsed since 00:00:00 UTC on 1 January 1970, known as the Unix epoch. It is timezone-independent, making it the standard way to store and compare dates across systems. A timestamp of 0 represents the epoch origin; a timestamp of 86400 represents exactly 24 hours after the epoch (1 January 1970, midnight UTC).
Count the digits. A 10-digit timestamp (e.g. 1713000000) is almost certainly seconds and represents a date around 2024. A 13-digit timestamp (e.g. 1713000000000) is almost certainly milliseconds and represents the same date. A 16-digit timestamp is microseconds. If in doubt, paste into this tool and check whether the result shows a plausible date — if you get a date in 2527, your millisecond timestamp was treated as seconds.
JavaScript’s Date object was designed in 1995 when millisecond precision was considered the right granularity for web interactions. Most Unix systems use seconds because that was sufficient for the applications of the 1970s. Neither is wrong — they are just different conventions. When interfacing between JavaScript and a Unix/Python backend, always divide JavaScript timestamps by 1000 before storing or comparing with second-based systems.
ISO 8601 is the international standard for date and time representation. The format is YYYY-MM-DDTHH:MM:SSZ for UTC (e.g. 2026-04-14T10:30:00Z) or YYYY-MM-DDTHH:MM:SS+05:30 for a specific timezone offset. The T separates date from time; Z means UTC; the plus/minus offset is hours and minutes from UTC. It is the format returned by most modern APIs and programming language date libraries.
On 19 January 2038 at 03:14:08 UTC, 32-bit signed integer timestamps will overflow and wrap to a large negative number. Systems that still use 32-bit integers to store timestamps — including some legacy embedded systems, databases with INT(11) timestamp columns and older C code — will display incorrect dates. The fix is to use 64-bit integers, which extend the range to over 292 billion years. Modern 64-bit operating systems and databases are not affected.
JavaScript: Date.now() (milliseconds) or Math.floor(Date.now()/1000) (seconds). Python: import time; int(time.time()) (seconds). PHP: time() (seconds). Ruby: Time.now.to_i (seconds). Go: time.Now().Unix() (seconds). Bash: date +%s (seconds). SQL (PostgreSQL): EXTRACT(EPOCH FROM NOW()). SQL (MySQL): UNIX_TIMESTAMP(). All of these can be pasted into the Date to Timestamp tab to verify the conversion.
No — Unix timestamps are always UTC-based. A timestamp of 1713000000 represents the same moment in time regardless of where in the world you are. The timezone only matters when converting to or from a human-readable date. When storing timestamps in a database, always store the raw Unix timestamp or UTC datetime, and convert to local time only for display in the user interface.
RFC 2822 is the format used in email headers (Date: field) and HTTP headers. It looks like: Mon, 14 Apr 2026 10:30:00 +0000. It includes the abbreviated day name, numeric date, abbreviated month, 4-digit year, time in HH:MM:SS and timezone offset. This format is returned by JavaScript’s Date.toString() and Date.toUTCString() methods and is commonly seen in server logs and email debugging.
Related tools

More free date and developer tools