🕐 Unix Timestamp Converter

Convert Unix timestamps to human-readable dates and vice versa. Live clock, world timezone display, and relative time breakdowns.

Current Unix Timestamp

1,786,953,383

.443 milliseconds

LIVE

Click timestamp to convert it ↑

UTC07:56:23 AM

IST01:26:23 PM

EST03:56:23 AM

GMT08:56:23 AM

QUICK LOAD:

🔢 ENTER TIMESTAMP

UNIT:

About Unix Timestamp Converter

A Unix timestamp (also called Epoch time or POSIX time) is the number of seconds elapsed since 00:00:00 UTC on 1 January 1970, not counting leap seconds. It is the universal standard for representing time in software — used by every major programming language, database, operating system, and web API. Because it is just an integer, it is timezone-independent: the same number represents the same moment everywhere in the world, regardless of local timezone.

Developers frequently encounter Unix timestamps in API responses, database records, log files, JWT token expiry fields, and AWS/GCP event payloads. Converting a raw number like 1735689600 to a human-readable date — or building a specific date back into a timestamp — requires knowing the timezone context. This tool converts in both directions across 12 world timezones simultaneously, shows relative time, and includes a live clock ticking with millisecond precision.

How to use the Unix Timestamp Converter

Timestamp → Date: Enter any Unix timestamp (in seconds or milliseconds) into the input field. The equivalent date and time appears instantly across all 12 timezones.
Date → Timestamp: Use the date/time picker to select a date and time. The corresponding Unix timestamp in both seconds and milliseconds is shown immediately.
Click the Live Clock to fill the converter with the current timestamp and see its world-timezone breakdown.
Use Quick Presets to jump to notable timestamps: Unix epoch (0), Y2K, start of current year, or the 2038 overflow boundary.
The Relative Time panel shows exactly how many years, months, days, hours, minutes, and seconds ago or in the future the timestamp is.

Features

🕐 Live Clock

Shows the current Unix timestamp ticking every 100ms with millisecond precision. Click it to instantly fill the converter with the current time.

🔢 Timestamp → Date

Enter any Unix timestamp in seconds or milliseconds and instantly see the equivalent date across 12 world timezones.

📅 Date → Timestamp

Pick a date and time and get the corresponding Unix timestamp in both seconds and milliseconds — copy either with one click.

🌍 World timezones

IST, UTC, EST, PST, GMT, GST, SGT, JST, AEDT, CET, CST — 12 timezones displayed simultaneously for instant global comparison.

⏱ Relative time

Shows exactly how many years, months, days, hours, minutes, and seconds ago or from now the timestamp represents.

📋 Quick presets

One-click presets: Now, Start of today, Start of year, Unix epoch (0), Y2K (946684800), and the Year 2038 overflow boundary (2147483647).

Frequently Asked Questions

How do I tell if a timestamp is in seconds or milliseconds?

A Unix timestamp in seconds (as of 2024) is a 10-digit number — around 1,700,000,000. A millisecond timestamp is a 13-digit number — around 1,700,000,000,000. If your timestamp has 13 digits, divide by 1,000 to get seconds. This tool auto-detects seconds vs. milliseconds based on the magnitude of the input.

What is the Unix epoch and why does it start in 1970?

The Unix epoch (January 1, 1970, 00:00:00 UTC) was chosen by the creators of Unix as a convenient starting point. At the time, 32-bit integers could represent dates up to January 19, 2038 — enough for foreseeable use. The date 1970-01-01 had no special significance; it was simply the current year when Unix time was designed.

What is the Year 2038 problem?

Systems that store Unix timestamps as signed 32-bit integers will overflow on January 19, 2038 at 03:14:07 UTC (timestamp 2147483647). After this point, a 32-bit counter wraps to a large negative number, causing dates to appear as December 13, 1901. Modern 64-bit systems are not affected — a 64-bit Unix timestamp won't overflow for approximately 292 billion years.

How do I convert a Unix timestamp in JavaScript?

To convert to a Date: new Date(timestamp * 1000) — multiply by 1000 because JavaScript's Date constructor takes milliseconds. To get the current timestamp: Math.floor(Date.now() / 1000). To convert a Date to timestamp: Math.floor(new Date('2024-01-01').getTime() / 1000).

How do I convert a Unix timestamp in Python?

Use datetime.fromtimestamp(ts) for local time or datetime.utcfromtimestamp(ts) for UTC. For milliseconds: datetime.fromtimestamp(ts / 1000). To get the current timestamp: import time; int(time.time()). The datetime module is built-in — no additional packages needed.

Unix timestamp converter: seconds, milliseconds, and timezone guide

Unix timestamps represent a point in time as the number of seconds (or milliseconds) elapsed since the Unix epoch: midnight UTC on January 1, 1970. They are timezone-agnostic by definition, which makes them ideal for storing and comparing time across distributed systems, databases, and APIs.

Timestamps in this format appear everywhere in backend development: JWT claims (exp, iat, nbf), database columns, S3 object metadata, log files, Kafka message timestamps, Redis TTLs, and REST API responses. The difficulty is that a raw integer like 1716789600 carries no obvious human meaning — you need to convert it to read it.

Braxik's Unix timestamp converter translates epoch values to human-readable dates in your local timezone and UTC, and converts human-readable dates back to epoch values. The most important thing it checks is whether the input is in seconds or milliseconds, because the same number means completely different things in each unit.

The converter is also a quick way to generate the current epoch for use in API tests, database queries, or scripts, without needing to remember the syntax in whichever language you happen to be working in at the moment.

How it works

The converter detects whether the input is in seconds or milliseconds based on the number of digits. A 10-digit integer is treated as seconds since the epoch; a 13-digit integer is treated as milliseconds. Both are converted to JavaScript Date objects internally, which use milliseconds. The resulting Date is formatted in UTC and in the user's local timezone using the browser's Intl.DateTimeFormat API.

For the reverse conversion (human-readable date to epoch), the input is parsed as a date string in ISO 8601 format or common locale formats. The resulting Date object's getTime() method returns the epoch in milliseconds, which is then divided by 1000 to get seconds.

The current timestamp button reads Date.now() from the browser, which returns the current wall-clock time in milliseconds. This is accurate to within a few milliseconds of the actual UTC time but may differ from a server's clock if your system clock is not synchronised.

Common uses

Check JWT exp, iat, and nbf claim values by converting them from epoch seconds to readable dates without doing mental math.
Convert log file timestamps from epoch to human-readable time when investigating a production incident across multiple services.
Generate a current epoch value for use in a curl request body, a database WHERE clause, or a unit test.
Calculate future or past timestamps for scheduling jobs, setting cache TTLs, or constructing test data with specific time offsets.
Debug timezone issues by comparing the UTC representation and local representation of a timestamp side by side.
Convert timestamps when migrating data between systems that use different timestamp conventions (Java's System.currentTimeMillis() vs Unix date command).
Verify that a database row's created_at or updated_at timestamp corresponds to the expected event time during data validation.

Before you rely on the result

A 10-digit epoch is seconds; a 13-digit epoch is milliseconds. Treating milliseconds as seconds gives a date around the year 56,000, and treating seconds as milliseconds gives a date in 1970. This is the most common conversion mistake.
Store timestamps in UTC in databases, logs, and APIs. Convert to local time only at the display layer — mixing storage timezones is a major source of subtle bugs.
Check timezone assumptions when comparing timestamps from different systems — two logs with the same apparent hour may represent different UTC times if they came from servers in different timezones.
Be aware of daylight saving time (DST) when converting timestamps to local time for human display — the same UTC hour maps to different local hours during DST transitions.
Validate that your programming language uses the expected epoch unit. Java's System.currentTimeMillis() returns milliseconds, while Unix shell commands like date +%s return seconds.
For database comparisons, check whether your ORM or query builder automatically converts timestamps or expects raw epoch values.
When using timestamps as cache keys or ETags, verify that the precision (seconds vs milliseconds vs nanoseconds) matches what the receiving system expects.