How do I convert a Unix timestamp to a readable date?

Paste the Unix timestamp (e.g. 1700000000) into the Epoch → Date panel. The tool auto-detects whether it's in seconds (10 digits), milliseconds (13 digits), or microseconds (16 digits) and shows the equivalent date in ISO 8601, UTC string, RFC 2822, your local timezone, and relative time ("3 hours ago") simultaneously. No button click needed — conversion is instant.

How do I convert a date to a Unix timestamp?

Use the Date → Epoch panel. Pick a date with the date input and enter a time — the output shows the Unix timestamp in seconds, Unix milliseconds, and ISO 8601 UTC format simultaneously. Click Now to get the current moment's timestamp.

How do I convert a Unix timestamp to a date in JavaScript?

Use new Date(timestamp * 1000).toISOString() for a seconds timestamp, or new Date(timestamp).toISOString() if it is already in milliseconds. For local time: new Date(timestamp * 1000).toLocaleString(). For UTC: new Date(timestamp * 1000).toUTCString(). This tool shows all these formats at once so you can copy exactly the one you need without writing code.

My timestamp looks like 1700000000000 — is it in seconds or milliseconds?

A 13-digit timestamp is in milliseconds (e.g. 1700000000000). A 10-digit timestamp is in seconds (e.g. 1700000000). JavaScript's Date.now() returns milliseconds. Most Linux/Unix system tools return seconds. This tool auto-detects which format you pasted and converts correctly — the precision label next to the panel title tells you which it detected.

How do I convert multiple timestamps at once from a log file or CSV?

Use the Batch Converter. Paste one timestamp per line — mixed seconds, milliseconds, and microseconds are handled correctly (each line is detected separately). The output table shows Unix seconds, ISO 8601 date, and relative time for every line, ready to copy or use.

Why does my JWT have an exp timestamp that I can't read?

JWT claims like exp (expiry), iat (issued at), and nbf (not before) are Unix timestamps in seconds. Paste the number directly into the Epoch → Date panel to see exactly when the token was issued and when it expires as a human-readable date. You can also use the JWT Decoder tool, which converts these claims automatically.

What is the Year 2038 problem?

Y2K38 affects 32-bit systems that store Unix timestamps as a signed 32-bit integer. The maximum 32-bit signed integer value represents January 19, 2038 at 03:14:07 UTC — after which 32-bit timestamps overflow to a negative number and dates become incorrect. Modern 64-bit systems are completely unaffected and can represent dates billions of years into the future.

⏱

Timestamp Converter

Timezone

Current Unix Time

seconds—

milliseconds—

ISO 8601—

Epoch → Date

Enter a Unix timestamp above to convert

Date → Epoch

Quick Reference

Batch Converter

One timestamp per line — auto-detects seconds, milliseconds, and microseconds

Related Tools

See all ->

Cron Expression BuilderVisual cron generator & scheduler

JWT DecoderDecode & verify tokens

SQL FormatterBeautify & minify SQL

JSON FormatterFormat & validate

API Request Generator & TesterGenerate · Test · 12 langs

Regex TesterTest & debug patterns

Diff CheckerCompare text & code

Code ScreenshotBeautiful code images

Unix Timestamp Converter — Epoch to Date & Date to Epoch

Updated May 14, 2026

Share & Support

What's included

Features

Live current Unix time — shows seconds, milliseconds, and ISO 8601, updating every second

Epoch → Date: paste any timestamp and get ISO 8601, UTC, RFC 2822, local time, day of week, and relative time

Date → Epoch: date + time picker outputs Unix seconds, milliseconds, and ISO 8601 simultaneously

Auto-detects precision — seconds (10-digit), milliseconds (13-digit), microseconds (16-digit)

Searchable timezone picker — shows local timezone, UTC, and any selected timezone side by side

Batch converter — paste one timestamp per line, get a conversion table with ISO 8601 and relative time; view the batch data as a table with our JSON Table Viewer

Quick Reference chips — Today midnight, Yesterday, 1 week ago, 30 days ago, Unix epoch, Y2K

100% client-side — uses browser Date and Intl APIs, no server upload, works offline; decode exp/iat claims from a JWT with our JWT Decoder

About this tool

Convert Unix Timestamps to Dates Instantly — Epoch Converter Online Free

You got a number like 1700000000 from an API response, a log file, a JWT token, or a database query and you need to know what date and time it represents. Paste it here and the readable date appears instantly — ISO 8601, UTC, RFC 2822, relative time ("3 hours ago"), and your local timezone all at once.

Unix timestamps are the universal format for time in software. Every major language (JavaScript, Python, Java, Go, PHP), every database (PostgreSQL, MySQL, MongoDB), and virtually every API uses them for storing and transmitting dates. They're timezone-independent integers — no ambiguity, easy to calculate with, easy to sort. But they're impossible to read directly, which is why this converter exists.

Is your timestamp in seconds or milliseconds? A 10-digit number like 1700000000 is seconds. A 13-digit number like 1700000000000 is milliseconds — that's what JavaScript's Date.now() returns. A 16-digit number is microseconds. This tool auto-detects which format you pasted and converts correctly without you having to specify.

Going the other way? Use the Date → Epoch panel to pick a date and time and get the Unix timestamp in seconds, milliseconds, and ISO 8601 UTC format simultaneously.

Multiple timestamps? The batch converter takes one timestamp per line and outputs a table of dates — useful for processing log exports or CSV files with timestamp columns.

Precision detection is threshold-based rather than a literal digit count: any value above roughly 9.9 trillion is treated as microseconds, anything above roughly 9.9 billion is milliseconds, and everything else is read as seconds — the same magnitude gap that separates a 2024-era seconds timestamp from a milliseconds one by three orders of magnitude, so the cutoff never misclassifies a real-world date. The relative-time label ("3 hours ago") walks a fixed list of unit sizes from a year down to a second, dividing the absolute difference from now by each in turn until one produces a value of at least 1 — that's why a timestamp two minutes away shows "in 2 minutes" rather than "in 120 seconds", and why a value ten months out correctly shows in months rather than in days. RFC 2822 output isn't built with a separate date-formatting routine; it takes the same UTC string JavaScript already produces and swaps the trailing "GMT" for "+0000", since RFC 2822 and toUTCString() agree on every other part of the format. The timezone list comes straight from Intl.supportedValuesOf('timeZone'), the IANA database built into the browser, with a short hardcoded fallback list for the rare browser that lacks it — so the searchable picker always reflects real timezones rather than a static, maintained-by-hand list that could drift out of date.

Everything runs in your browser using JavaScript's built-in Date and Intl APIs. No server, no sign-up, works offline.

Step by step

How to Use

1
Read the live current Unix timeThe Current Unix Time card at the top of the page shows the current timestamp in seconds, milliseconds, and ISO 8601 format, updating every second. Click Copy next to any row to instantly copy it to your clipboard — useful when you need to insert a "now" timestamp into a database query, API test, or config file.
2
Convert an epoch timestamp to a readable datePaste any Unix timestamp into the Epoch → Date panel input and click Now to auto-fill the current time, or type any number directly. The tool auto-detects whether the input is in seconds (10 digits), milliseconds (13 digits), or microseconds (16 digits) and labels the precision. Results appear simultaneously in ISO 8601, UTC String, RFC 2822, day of week, relative time, and your local timezone.
3
Select a timezone for cross-region outputUse the Timezone picker in the tool header to add a custom timezone to the Epoch → Date output. Type any city or timezone name — "Tokyo", "America/New_York", "Europe/Berlin" — and the matching timezone appears in the dropdown. The Epoch → Date panel then shows the time in your local timezone, UTC, and the selected timezone simultaneously.
4
Convert a date and time to a Unix timestampUse the Date → Epoch panel to convert in the other direction. Pick a date using the date input and set a time using the time input — they default to your current local date and time. The panel outputs Unix seconds, Unix milliseconds, ISO 8601 UTC, and relative time simultaneously. Click Now to reset to the current moment.
5
Use quick reference chips or batch convert multiple timestampsClick any Quick Reference chip — Today midnight, Yesterday, 1 week ago, Unix epoch, Y2K — to instantly load that timestamp into the Epoch → Date panel. For bulk conversion, paste multiple timestamps (one per line) into the Batch Converter textarea — the table shows Unix seconds, ISO 8601 date, and relative time for each line. Mixed precisions (seconds, milliseconds, microseconds) in the same batch are auto-detected and handled correctly.

Real-world uses

Common Use Cases

🔌

Read an integer timestamp from an API response or database query

REST and GraphQL APIs return timestamps as integers. Paste the value directly and immediately see the human-readable date — no mental math or format guessing required.

📋

Convert a column of log timestamps to readable dates in bulk

Server logs, application traces, and database audit logs use Unix timestamps. Batch-convert a column of log timestamps to ISO dates to correlate events across systems.

🔑

Read the exp and iat claims in a JWT token as human-readable dates

JWT tokens contain iat (issued at) and exp (expiry) claims as Unix timestamps. Paste the value to see when a token was issued and exactly when it expires. Use our JWT Decoder to decode the full token at once.

🌍

Convert a UTC epoch to multiple timezones for cross-region scheduling

Convert a UTC epoch to multiple timezones simultaneously using the timezone picker — useful for scheduling meetings, deployments, or events across regions.

🗄️

Verify database timestamps are correct after a migration or backfill

PostgreSQL, MySQL, and MongoDB store dates as integers or epoch values. Convert database timestamps to readable dates to verify data integrity during migrations.

📱

Check whether a JavaScript Date.now() value is in seconds or milliseconds

JavaScript's Date.now() returns milliseconds. Quickly convert between ms and seconds, check relative time displays, and verify date arithmetic in your app.

Got questions?

Frequently Asked Questions

A Unix timestamp is the number of seconds elapsed since January 1, 1970 at 00:00:00 UTC (the Unix epoch). It is a single timezone-independent integer used universally in programming, databases, and APIs to represent any moment in time. All major languages support it natively.

A seconds timestamp is 10 digits (e.g. 1700000000). A milliseconds timestamp is 13 digits (e.g. 1700000000000). JavaScript's Date.now() returns milliseconds. Linux date +%s returns seconds. This tool auto-detects which you've pasted and converts correctly — look for the precision badge next to the panel title.

The current Unix timestamp is shown live at the top of this page and updates every second. You can also run Math.floor(Date.now()/1000) in any browser console to get it in seconds, or Date.now() for milliseconds.

Use new Date(timestamp * 1000).toISOString() for a seconds timestamp, or new Date(timestamp).toISOString() for milliseconds. For local time: new Date(ts * 1000).toLocaleString(). For UTC: new Date(ts * 1000).toUTCString(). This tool shows all formats at once so you can copy the one you need.

ISO 8601 is a standardised human-readable date format: 2024-01-15T10:30:00.000Z. The T separates date from time, and the Z suffix means UTC. It is the recommended format for APIs, JSON payloads, and file metadata because it is unambiguous and sortable alphabetically.

The Unix epoch was chosen as a practical reference when Unix was developed in the early 1970s. It predates all real-world computer usage at the time, making all timestamps positive integers. The exact date was arbitrary — it just needed to be a fixed point in the past. Every major language and system uses the same epoch.

The Y2K38 problem affects 32-bit systems that store Unix timestamps as a signed 32-bit integer. The max value overflows on January 19, 2038 at 03:14:07 UTC, causing timestamps to roll back to negative numbers. Modern 64-bit systems are completely unaffected and can represent dates billions of years in the future.

Yes — use the Batch Converter at the bottom of the page. Paste one timestamp per line (mixing seconds, milliseconds, and microseconds is fine — each line is auto-detected separately). The output table shows Unix seconds, ISO 8601, and relative time for every line.

No. All conversions run entirely in your browser using JavaScript's built-in Date and Intl APIs. No data is sent anywhere. The tool works offline once the page has loaded.

RFC 2822 is the date format used in email headers: Mon, 15 Jan 2024 10:30:00 +0000. It is also used in HTTP headers and RSS/Atom feeds. This tool outputs RFC 2822 alongside ISO 8601 and UTC string formats for every timestamp conversion.