Unix Timestamp Converter – Epoch to Date & Back | FistHost

Unix Timestamp Converter

100% free · Runs 100% in your browser · No signup needed

---

Unix time = seconds since 1970-01-01T00:00:00Z (UTC), the epoch — leap seconds are not counted. Millisecond timestamps are what JavaScript’s Date uses. Auto-detect by digits: 10 → seconds, 13 → ms, 16 → µs, 19 → ns. Fun fact: 32-bit signed timestamps max out at 2,147,483,647 (2038-01-19T03:14:07Z) — the Year 2038 problem.

Try an example: 2026-01-01 00:00 UTC

About Unix Timestamp Converter

If you've ever stared at a number like 1704067200 in a database, a log file, or an API response and wondered what date it represents, you needed a Unix Timestamp Converter. Unix time counts the seconds elapsed since 1970-01-01T00:00:00Z (UTC) — the "epoch" — and it underpins nearly every system on the internet. FistHost's converter translates timestamps to human dates and back, instantly, in your browser.

What is a Unix timestamp?

Unix time is simply the number of seconds that have passed since midnight on January 1, 1970, in UTC. That moment — 1970-01-01T00:00:00Z — is called the epoch. One detail worth knowing: leap seconds are not counted in Unix time, so it's not a perfect measure of elapsed physical time — it's a convention every major system agrees on.

• Seconds: the classic 10-digit form, e.g. 1704067200 = 2024-01-01 00:00:00 UTC.
• Milliseconds: seconds × 1000 — this is what JavaScript's Date uses, e.g. 1704067200000.
• Microseconds / nanoseconds: 16- and 19-digit forms used by high-precision systems and databases.

What the tool does

• Timestamp → date: paste any timestamp; the tool auto-detects the unit by magnitude — 10 digits = seconds, 13 = milliseconds, 16 = microseconds, 19 = nanoseconds — with a manual override if you want to force a unit.
• Shows both UTC and your local time: no more mental timezone math; see the exact moment in UTC and in the visitor's own timezone side by side.
• Date → timestamp: pick a date and time with the datetime picker to get the timestamp, in any of the four units.
• "Now" button: one click gives you the current timestamp — perfect for seeding test data.
• Relative time: see "3 hours ago" / "in 2 days" style human phrasing alongside the exact date.
• Copy button on every output.

Fun fact: the Year 2038 problem

The maximum value of a signed 32-bit integer is 2,147,483,647 — which as a Unix timestamp is 2038-01-19T03:14:07Z. Systems still storing time in 32-bit signed integers will overflow on that date, exactly like Y2K in miniature. Modern systems use 64-bit time and are fine, but embedded devices and legacy databases may still bite. Paste 2147483647 into the tool and see the fateful second for yourself.

Where you'll meet Unix timestamps in the wild

• APIs: REST APIs constantly return created_at / updated_at as epoch seconds or milliseconds.
• Databases: MySQL, PostgreSQL, and MongoDB-adjacent systems store or export epoch values.
• Log files: server and application logs timestamp events in epoch form for compactness.
• JavaScript: Date.now() returns milliseconds — the #1 source of "why is my date in the year 52,000?" bugs when developers treat it as seconds.
• JWT tokens: the exp and iat claims are Unix timestamps in seconds — decode them with our JWT tooling and verify moments here.
• Cron and scheduling: converting "next run at" values when debugging scheduled jobs.

FistHost hosting for developers

Debugging timestamps in your app's logs at 2 AM? You need hosting with real tools and honest pricing. FistHost shared hosting starts at just $0.99/month, and the annual plan includes a free domain — deploy your side projects, APIs, and cron-driven apps without the enterprise price tag.

Common timestamp pitfalls (and how the tool helps)

• Seconds vs. milliseconds: feeding milliseconds to something expecting seconds lands you tens of thousands of years in the future. The auto-detect reads the digit count so you don't have to guess — but the manual override is there when a system is genuinely ambiguous.
• Timezone confusion: the timestamp itself is always UTC; confusion comes from display. The tool shows UTC and local time together so you can see both interpretations at once.
• Negative timestamps: dates before 1970 are negative numbers (e.g. -86400 = 1969-12-31). The tool handles them correctly.
• String vs. number: some APIs return timestamps as strings; the tool tolerates both.

Quick reference: landmark timestamps

• 0 → 1970-01-01T00:00:00Z (the epoch itself)
• 1000000000 → 2001-09-09T01:46:40Z (the "billion second" party)
• 1234567890 → 2009-02-13T23:31:30Z
• 1704067200 → 2024-01-01T00:00:00Z
• 2147483647 → 2038-01-19T03:14:07Z (32-bit limit)

Developer workflow: pair with FistHost's date & time toolkit

Timestamps rarely travel alone. Measure spans with the Date Duration Calculator, convert between zones with the Time Zone Converter, skip non-working days with the Working Days Calculator, and count down to launches with the Countdown Timer. Every one of them is free and runs entirely client-side.

Ship your projects on FistHost

FistHost builds free developer tools because we believe the web should be accessible — no sign-ups, no tracking, no paywalls. When your project outgrows localhost, FistHost shared hosting at $0.99/month with a free domain on the annual plan gets it live in minutes. Build, convert, deploy — all with FistHost.

Unix time in the languages you actually use

Every major language has a one-liner for epoch time — but they disagree on units, which is exactly why this tool exists:

• JavaScript: Date.now() → milliseconds; Math.floor(Date.now()/1000) → seconds.
• Python: int(time.time()) → seconds; datetime.fromtimestamp(ts, tz=timezone.utc) → datetime.
• PHP: time() → seconds; date('Y-m-d H:i:s', $ts) → formatted date.
• SQL: MySQL UNIX_TIMESTAMP('2024-01-01 00:00:00') → seconds; FROM_UNIXTIME(1704067200) → datetime.
• Java: System.currentTimeMillis() → milliseconds; Instant.now().getEpochSecond() → seconds.

The pattern to memorize: web/Java APIs lean milliseconds, Unix/PHP/SQL lean seconds. When copying a value between systems, convert it here first and sanity-check the resulting date — a year-52,000 result means you mixed the units.

Debugging with timestamps: a practical workflow

• Log forensics: paste an epoch from a log line into the tool, read the UTC and local times, and correlate with incident timelines without writing a script.
• "Why is this date wrong?" — the three usual suspects are seconds-vs-milliseconds, a timezone applied twice, and a timestamp stored as a string that got concatenated instead of added. The tool's side-by-side UTC/local display exposes the timezone class of bug immediately.
• Scheduling checks: convert a cron job's "next run" epoch to confirm it fires when you expect, especially across daylight-saving transitions (epoch math itself is DST-proof; display conversions aren't).
• Token expiry: JWT exp claims are epoch seconds — paste one here to see exactly when a token dies, in your own timezone.
• Test fixtures: hit the "Now" button, copy the value, and seed deterministic test data with a known-good current timestamp.

Why epoch time won: the engineering case

Storing dates as a single integer turned out to be one of computing's best ideas:

• Sorting and comparison are trivial: bigger number = later time, no parsing needed.
• Arithmetic is trivial: "24 hours from now" is just +86400.
• Timezone-free storage: the value is always UTC; timezones are a display concern only.
• Compact: 10 digits beat any date string for storage and indexing.
• Language-agnostic: every platform can parse an integer, so APIs pass timestamps across language boundaries without format negotiation.

The relative-time readout ("3 hours ago") in the tool exists because humans don't think in integers — machines do, and the converter is the bridge between the two.

Frequently asked questions

Why does JavaScript use milliseconds instead of seconds?

Brendan Eich's original Date implementation chose millisecond precision, and the web has been converting ever since. Always check the unit before doing date math in JS.

Are leap seconds included in Unix time?

No. Unix time ignores leap seconds by definition, so converting between Unix time and UTC around a leap second needs special handling — for everyday use, you can ignore this.

Can I convert dates before 1970?

Yes — they appear as negative timestamps, and the tool converts them just like positive ones.

Is anything uploaded?

Nothing. All conversion happens locally in your browser; your timestamps and dates never leave your machine.