Unix Timestamp Converter
Unix timestamp converter — paste any epoch (seconds or milliseconds, auto-detected) and get a human date in UTC and your local timezone. Runs in the browser, no upload.
About the Unix Timestamp Converter
A Unix timestamp (also called epoch time or POSIX time) is the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC, ignoring leap seconds. It is the lingua franca of computer timekeeping — every Linux box, REST API payload, JWT token, database row and log line stores time this way because a single signed integer is portable, comparable and timezone-free. Developers and SREs hit timestamps constantly: chasing a stack trace, replaying a webhook, lining up two events across servers in different regions, or proving a row was written before a deploy. This converter handles all the common variants in one input box. It auto-detects the unit by digit count — 10 digits is seconds, 13 is milliseconds (JavaScript Date.now()), 16 is microseconds (Python time.time_ns()/1000), 19 is nanoseconds (Go time.Now().UnixNano()). It also keeps your data on your machine: log timestamps can quietly leak request IDs, customer IDs and incident times, so we never upload what you paste — the math happens in your browser. For practical work it covers the situations you actually meet at 2 AM. Pasting a number from a JSON API response, a MongoDB ObjectId, a Postgres extract(epoch from now()), a Cloudflare log or a Kafka record header tells you immediately what moment it points to, in UTC and in your local timezone. Going the other way — date to timestamp — is just as fast: pick a date, copy the seconds value for date +%s, MySQL UNIX_TIMESTAMP(), or JWT iat/exp. Seconds vs milliseconds confusion is the single most common bug here, so the digit count is shown next to the input, and round-trip values for both units are exposed in the output so you can grep your code and pick the right one. There is no signup, no ad tracking and no rate limit.
Why use this Unix timestamp converter
Seconds and milliseconds, auto-detected
Paste any number and the converter detects the unit by length: 10 digits is seconds, 13 is milliseconds (Java / JavaScript Date.now()), 16 is microseconds, 19 is nanoseconds. You never have to remember to divide by 1000.
Timezone-aware output
Every result is shown in UTC, your browser's local timezone, ISO 8601, RFC 1123 and a human-readable relative form ("3 hours ago"). Copy whichever one your bug report, JIRA ticket or git commit needs.
Runs locally, nothing uploaded
Log timestamps can be sensitive — they pin down request IDs, user IDs and incident windows. All conversion happens in your browser; nothing is sent to a server. Safe to paste production timestamps.
Round-trip ready for any stack
The same value is exposed as Unix seconds, Unix milliseconds, ISO 8601 and Excel/FILETIME/.NET Ticks. Plug straight into date +%s, JWT iat, MySQL FROM_UNIXTIME or .NET DateTimeOffset.FromUnixTimeSeconds.
Frequently Asked Questions
How do I convert a Unix timestamp to a date?
Paste the timestamp into the input above. The converter detects whether it's seconds or milliseconds by counting digits (10 = seconds, 13 = milliseconds) and renders the moment in UTC, in your browser's local timezone, and in ISO 8601. For example, 1700000000 is 2023-11-14T22:13:20 UTC. If you prefer doing it in code: JavaScript new Date(1700000000 * 1000).toISOString(), Python datetime.utcfromtimestamp(1700000000), or Linux date -u -d @1700000000.
What is the difference between seconds and milliseconds in a timestamp?
Both count from the same epoch (1970-01-01 00:00:00 UTC), but in different units. Unix seconds — used by Linux date +%s, MySQL UNIX_TIMESTAMP(), Python time.time() (as int), PostgreSQL extract(epoch from now()), JWT iat/exp — are about 10 digits long today (e.g. 1700000000). Milliseconds — used by JavaScript Date.now(), Java System.currentTimeMillis(), MongoDB Date — are about 13 digits long (e.g. 1700000000000). The converter detects the unit by digit count, so you don't have to remember to multiply or divide by 1000.
How do I get the current Unix timestamp?
Different stacks expose it differently. JavaScript: Math.floor(Date.now() / 1000) for seconds, Date.now() for milliseconds. Python: int(time.time()) or time.time_ns() // 1_000_000_000. Bash / Linux: date +%s for seconds, date +%s%3N for milliseconds. Go: time.Now().Unix() or .UnixMilli(). PHP: time(). MySQL: SELECT UNIX_TIMESTAMP(). PostgreSQL: SELECT EXTRACT(epoch FROM now())::bigint. The tool above also shows the live current timestamp updating every second — copy with one click.
What is the Y2038 problem?
A signed 32-bit Unix timestamp can hold values up to 2,147,483,647 — which corresponds to 2038-01-19 03:14:07 UTC. One second later it overflows back to a negative number, around December 1901. The bug bites legacy C code using time_t as int32, plus older embedded firmware, ext3 inodes and a few protocols (NTPv4 wraps in 2036). Modern 64-bit systems, JavaScript's Number, Java's long and current Linux kernels use 64-bit timestamps where overflow is 292 billion years away. If your stack is still on 32-bit time, fix it before 2038.
How do I convert milliseconds to seconds?
Divide by 1000 and (usually) drop the remainder. In JavaScript: Math.floor(Date.now() / 1000). In Python: int(time_ms / 1000) or time_ms // 1000. In SQL: timestamp_ms / 1000. Going the other way, multiply by 1000: secondsTimestamp * 1000. Don't lose precision silently — if you genuinely need sub-second accuracy (financial events, distributed traces, OpenTelemetry spans), keep the original unit and only convert at the display layer.
What format does JavaScript use?
JavaScript's Date.now() and (new Date()).getTime() return Unix time in milliseconds — a 13-digit number, not seconds. The Date constructor and new Date(ms) also expect milliseconds. This is the single most common gotcha when consuming a JSON API from a Python or Linux backend: if you pass a 10-digit seconds value to new Date(), you'll get a date in 1970. Always multiply seconds by 1000 before handing them to Date, or use new Date(seconds * 1000).
How do I convert ISO 8601 to a Unix timestamp?
Use the Date → timestamp tab above and the tool will return both seconds and milliseconds, plus an ISO 8601 echo so you can confirm timezone interpretation. In code: JavaScript Math.floor(new Date('2026-06-15T12:00:00Z').getTime() / 1000); Python int(datetime.fromisoformat('2026-06-15T12:00:00+00:00').timestamp()); Bash date -d '2026-06-15T12:00:00Z' +%s. Always include a timezone in the ISO string (Z or ±HH:MM) — otherwise the parser falls back to the machine's local timezone and you get a different number on every server.
Why are Unix timestamps usually expressed in UTC?
Because a Unix timestamp has no timezone — it's just a count of seconds since a single fixed moment in UTC. Two servers in New York and Tokyo writing time.time() at exactly the same instant produce the same number. Display timezone is a presentation choice that happens later. Storing timestamps in UTC (or as raw Unix integers) and converting to local time only at the UI layer is the standard pattern; storing local time in a database is what leads to DST bugs and duplicate-hour rows on the autumn clock change.